constants.alu

// Simple constant values
const INT: u32 = 1;
const STR = "Hello";
const ARR = [1, 2, 3];

// Constants with compile-time evaluation
const EVAL: u32 = 1 + 1;

// Complex expressions with loops and function calls
const RANDOM_NUMBERS: [usize; 20] = {
    let rng = std::random::Pcg32 {
        state: 0xa285d44c06ab9542,
        increment: 0x71bc6da31db36d8d,
    };

    let ret: [usize; 20];
    (0..20)
        .map(|&rng, _: i32| -> usize { rng.next(0usize..=10) })
        .fill_slice(&ret);

    ret
};

// Enum variants can have constant values
enum Color {
    Red   = (255 << 16) |   (0 << 8) |   0,
    Green =   (0 << 16) | (255 << 8) |   0,
    Blue  =   (0 << 16) |   (0 << 8) | 255,
}

struct Foo {
    range: std::range::Range<i32>
}

// arrays, tuples and structs are supported
const OPT: Option<i32> = Option::none();

const COMPLEX_CONST: [(Foo, Foo); 2] = [
    (Foo { range: 1..2 }, Foo { range: 3..4 }),
    (Foo { range: 5..6 }, Foo { range: 7..8 }),
];

fn main() {
    use std::fmt::{hex, zero_pad};

    print!("RANDOM NUMBERS = [");
    for (idx, num) in RANDOM_NUMBERS.iter().enumerate() {
        if idx == 0 {
            print!("{}", num);
        } else {
            print!(", {}", num);
        }
    }
    println!("]");

    // Constants can be used e.g. in array sizes...
    let arr: [i32; RANDOM_NUMBERS[5]];
    println!("arr.len() = {}", arr.len());

    // ...or as tuple indices
    let tup = (1, "a", true);
    println!("{}", tup.(RANDOM_NUMBERS[5] % 3));

    for color in [Color::Red, Color::Green, Color::Blue] {
        println!("{}", (color as i32).hex().zero_pad(6));
    }

    println!("OPT = {}", OPT);
    println!("COMPLEX_CONST[0].1.range.lower = {}", COMPLEX_CONST[0].1.range.lower);
}