[ajdude]

I like in Ada's type system in that I can do constraints such as "type Positive is Integer range 1 .. Integer'Last;" to give me a number that I know must always be in the positive range of an integer, and it's easily readable in plain text.

From what I have read, trying to do something like "type Element is Integer range 100 .. 1000;" in rust requires something along the lines of

     struct BoundedU16<const MIN: u16, const MAX: u16>(u16);
     impl<const MIN: u16, const MAX: u16> BoundedU16<MIN, MAX> {
         pub const fn new(value: u16) -> Result<Self, BoundError> {
             if value >= MIN && value <= MAX {
                 Ok(Self(value))
             } else {
                 Err(BoundError(value, MIN, MAX))
             }
         }
     }

[crabbone]

Now how about using this type as an array index? In Ada, when you declare an array with this kind of type as an index, it automatically knows its size, generates a bunch of methods to help with iteration and element access, and these methods are "generic" in a sense that the programmer doesn't need to know the lowest or highest index of an array in order to iterate over it.

On the other hand: these types make life hard. Kind of like Rust's lifetimes. Sometimes obviously correct code doesn't compile and you need to twist and tie yourself into knots in order to get a much more convoluted version to compile. Well, like Rust.

They are indeed very similar, and require approximately the same level of pain tolerance.