// Generic over type - this was always fine  
struct Container<T> {  
    data: Vec<T>  // T can be anything  
}

// Generic over SIZE - didn't work before Rust 1.51  
// The compiler would just... reject this  
struct FixedArray<T, const N: usize> {  
    data: [T; N]  // "N is not a type!" the compiler screamed  
}

// Before: One function per array size (kill me)  
fn parse_header_16(data: [u8; 16]) -> Header {   
    /* parse logic here */   
}  
fn parse_header_32(data: [u8; 32]) -> Header {   
    /* SAME logic, different number */   
}  
fn parse_header_64(data: [u8; 64]) -> Header {   
    /* STILL the same logic */   
}  
// ...and we had 16 MORE of these  
// I'm not joking, we actually did this

// After: ONE function, any size (finally!)  
fn parse_header<const N: usize>(  
    data: [u8; N]  // N is checked at compile time  
) -> Header   
where  
    [(); N - 16]: ,  // weird syntax but it ensures N >= 16  
{  
    // Extract protocol version from first byte  
    let protocol_version = data[0];  

    // Message type from second byte  
    let message_type = data[1];  

    // Payload length from bytes 2-3, big-endian  
    let payload_length = u16::from_be_bytes([  
        data[2], data[3]  
    ]);  

    // Build the header struct  
    Header {  
        version: protocol_version,  
        msg_type: message_type,  
        len: payload_length,  
    }  
}

// Benchmark: parsing 1 million headers  
// Before (with Vec): 89ms  
// After (stack arrays): 47ms  
// That's 47% faster, zero allocations

 struct Matrix {  
    rows: usize,      // runtime values, heap allocated  
    cols: usize,      // dynamic but slow  
    data: Vec<f32>,   // allocations everywhere  
}

 // This generated 16 struct definitions  
// Don't even get me started  
macro_rules! matrix {  
    ($rows:expr, $cols:expr) => { /* templated nightmare */ };  
}

#[derive(Clone, Copy)]  // can copy because it's all stack  
struct Matrix<T, const ROWS: usize, const COLS: usize> {  
    data: [[T; COLS]; ROWS],  // 2D array, compile-time size  
}  

impl<T, const R: usize, const C: usize>   
    Matrix<T, R, C>   
where  
    T: Copy + std::ops::Add<Output = T> +  // needs to be copyable and addable  
       std::ops::Mul<Output = T>,           // and multipliable  
{  
    // Matrix multiplication - type system enforces dimensions!  
    fn multiply<const C2: usize>(  
        &self,  
        other: &Matrix<T, C, C2>,  // columns must match our rows  
    ) -> Matrix<T, R, C2> {  
        // Result matrix - zero-initialized  
        let mut result = Matrix {  
            data: [[T::default(); C2]; R],  
        };  

        // Standard matrix multiplication  
        for i in 0..R {                    // for each row in self  
            for j in 0..C2 {               // for each column in other  
                let mut sum = T::default();  
                for k in 0..C {            // dot product  
                    sum = sum +   
                        self.data[i][k] *  // our row  
                        other.data[k][j];  // their column  
                }  
                result.data[i][j] = sum;   // store result  
            }  
        }  

        result  
    }  
}

#[repr(C)]  // C layout, predictable memory  
struct Packet<const HEADER_SIZE: usize,   
              const PAYLOAD_SIZE: usize>   
{  
    header: [u8; HEADER_SIZE],    // fixed header  
    payload: [u8; PAYLOAD_SIZE],  // fixed payload  
}  

impl<const H: usize, const P: usize>   
    Packet<H, P>   
{  
    // Parse from raw bytes - sizes must match!  
    fn from_bytes(data: &[u8; H + P]) -> Self {  
        let mut header = [0u8; H];    // allocate header buffer  
        let mut payload = [0u8; P];   // allocate payload buffer  

        // Split the data at header boundary  
        header.copy_from_slice(&data[..H]);  
        payload.copy_from_slice(&data[H..]);  

        Self { header, payload }  
    }  

    // Validate packet checksum  
    fn validate(&self) -> Result<(), ProtocolError>   
    where  
        [(); H - 4]: ,  // ensure header is at least 4 bytes for checksum  
    {  
        // Calculate checksum over data  
        let checksum = self.calculate_checksum();  

        // Last 4 bytes of header are expected checksum  
        let expected = u32::from_be_bytes([  
            self.header[H-4],  
            self.header[H-3],  
            self.header[H-2],  
            self.header[H-1],  
        ]);  

        // Verify they match  
        if checksum != expected {  
            return Err(ProtocolError::InvalidChecksum);  
        }  

        Ok(())  
    }  
}  
// Type aliases for specific protocols - the sizes are in the type!  
type TcpPacket = Packet<20, 1460>;    // TCP header + typical MTU payload  
type UdpPacket = Packet<8, 65527>;    // UDP header + max UDP payload

struct FixedString<const N: usize> {  
    bytes: [u8; N],  // fixed buffer  
    len: usize,      // how much is used  
}  

impl<const N: usize> FixedString<N> {  
    // Can use this in const context (compile-time!)  
    const fn new() -> Self {  
        Self {  
            bytes: [0; N],  // zero-initialized  
            len: 0,         // empty  
        }  
    }  

    // Add string data - bounds checked  
    fn push_str(&mut self, s: &str)   
        -> Result<(), StringError>   
    {  
        // Check if it fits  
        if self.len + s.len() > N {  
            return Err(StringError::Overflow);  // nope  
        }  

        // Copy the bytes in  
        self.bytes[self.len..self.len + s.len()]  
            .copy_from_slice(s.as_bytes());  

        self.len += s.len();  // update length  

        Ok(())  
    }  
}  
// Type aliases for common uses  
type Username = FixedString<32>;   // usernames fit in 32 bytes  
type SessionId = FixedString<64>;  // session IDs fit in 64 bytes

struct RingBuffer<T, const SIZE: usize>   
where  
    T: Copy,  // needs to be copyable  
{  
    data: [Option<T>; SIZE],     // fixed-size array of slots  
    head: AtomicUsize,            // write position (atomic for lock-free)  
    tail: AtomicUsize,            // read position (atomic)  
}  

impl<T, const SIZE: usize> RingBuffer<T, SIZE>  
where  
    T: Copy,  
    [(); SIZE - 1]: ,  // ensure SIZE > 1 (otherwise not a ring)  
{  
    // Can create at compile time  
    const fn new() -> Self {  
        Self {  
            data: [None; SIZE],           // all slots empty  
            head: AtomicUsize::new(0),    // start at 0  
            tail: AtomicUsize::new(0),    // start at 0  
        }  
    }  

    // Push item - lock-free  
    fn push(&self, item: T) -> Result<(), T> {  
        // Load current head position  
        let head = self.head.load(Ordering::Acquire);  
        let next = (head + 1) % SIZE;  // next position (wraps around)  

        // Check if buffer is full  
        if next == self.tail.load(Ordering::Acquire) {  
            return Err(item);  // full, can't push  
        }  

        // Write the item (unsafe but we've checked bounds)  
        unsafe {  
            let ptr = self.data.as_ptr() as *mut Option<T>;  
            *ptr.add(head) = Some(item);  // store item at head  
        }  

        // Update head position (release so readers see the write)  
        self.head.store(next, Ordering::Release);  
        Ok(())  
    }  
}

// Before: Why these numbers? Who knows!  
fn aes_encrypt(plaintext: &[u8]) -> [u8; 16] {  
    let mut state = [0u8; 16];  // magic number alert  
    // ...  
}  

fn sha256_hash(data: &[u8]) -> [u8; 32] {  
    let mut hash = [0u8; 32];  // another magic number  
    // ...  
}

// Define what a block cipher needs  
trait BlockCipher {  
    const BLOCK_SIZE: usize;  // how big are blocks?  
    const KEY_SIZE: usize;    // how big are keys?  
}  
// AES-128: 16-byte blocks, 16-byte keys  
struct AES128;  
impl BlockCipher for AES128 {  
    const BLOCK_SIZE: usize = 16;  
    const KEY_SIZE: usize = 16;  
}  
// AES-256: 16-byte blocks, 32-byte keys  
struct AES256;  
impl BlockCipher for AES256 {  
    const BLOCK_SIZE: usize = 16;  
    const KEY_SIZE: usize = 32;  
}  
// Generic cipher implementation  
struct Cipher<C: BlockCipher> {  
    key: [u8; C::KEY_SIZE],    // key size from trait  
    _marker: PhantomData<C>,   // zero-size marker  
}  
impl<C: BlockCipher> Cipher<C> {  
    // Encrypt one block - sizes from trait constants  
    fn encrypt(  
        &self,   
        block: [u8; C::BLOCK_SIZE]  // input block  
    ) -> [u8; C::BLOCK_SIZE] {      // output block  
        let mut result = [0u8; C::BLOCK_SIZE];  
        // encryption logic here  
        // type system ensures correct sizes  
        result  
    }  
}

struct StateMachine<const STATES: usize,      // number of states  
                    const TRANSITIONS: usize>  // number of transition types  
{  
    state_handlers: [fn(); STATES],  // function for each state  
    transition_table: [[Option<usize>; STATES]; TRANSITIONS],  // transition table  
    current_state: usize,  // where we are now  
}  
impl<const S: usize, const T: usize>   
    StateMachine<S, T>   
{  
    // Can construct at compile time  
    const fn new(  
        handlers: [fn(); S],                           // state handlers  
        transitions: [[Option<usize>; S]; T],  // transition rules  
    ) -> Self {  
        Self {  
            state_handlers: handlers,  
            transition_table: transitions,  
            current_state: 0,  // start at state 0  
        }  
    }  

    // Process an event  
    fn process_event(&mut self, event: usize) {  
        // Look up next state from transition table  
        if let Some(next_state) =   
            self.transition_table[event][self.current_state]   
        {  
            self.current_state = next_state;          // transition  
            (self.state_handlers[next_state])();      // run handler  
        }  
    }  
}

 // This DOESN'T COMPILE - multiplication not supported in bounds  
impl<const N: usize> Matrix<N, N>   
where  
    [(); N * N]: ,  // nope, can't multiply in bounds  
{  
    // ...  
}  
// Workaround: pre-compute the const  
const SIZE: usize = 4;  
const SQUARED: usize = SIZE * SIZE;  // computed outside  
impl Matrix<SIZE, SQUARED> { /* works */ }

 // DOESN'T WORK - heap allocation not allowed in const  
const fn create_buffer<const N: usize>() -> Vec<u8> {  
    Vec::with_capacity(N)  // Error: Vec::with_capacity not const  
}

 // DOESN'T WORK YET - can't do math in type positions  
fn split<T, const N: usize>(  
    data: [T; N]  
) -> ([T; N/2], [T; N/2])  // N/2 not allowed here  
where  
    [(); N / 2]: ,  // this constraint also fails  
{  
    // ...  
}