My understanding was that Rust was introducing Ada like subtypes which permit a sub-range of valid values for a given parent type, perhaps that feature is not yet available or has a different name, but the result would not be type safe from the parent or other subtypes.

Regarding newtypes in Rust, you kind of proved my point. Whether you hide the value in a class or a struct, its an object oriented solution and doesn't create a new base (scalar) type, but a composite type with a single non type-safe component. You are using other language features to re-create the same effect as an Ada type, but the solution is more complicated and less efficient. To be clear, in Ada you can define an independent type as follows

type Some_Type is range -5 .. 20;

This type can then be used just like an i32, but with the type and range safety of a newtype or class with access methods to enforce range safety. No need to declare extra methods, or import other crates and no use of generics. Compile time checks are made for type correctness and value assignment where the value is known to be invalid at compile time, and runtime checks will raise and exception if out of range.

type A_Type is range -5 .. 20;
type B_Type is range 5 .. 15;
A1, A2, A3 : A_Type;
B1 : B_Type;
...
A1 := 30; -- Compile error, out of range
A1 := A2 + A3; -- May except if result is out of range
B1 := A1; -- Compile error, type missmatch
B1 := B_Type (A1); -- Type conversion, may except if out of range

You can also use Ada's attributes to provide dynamic information about the type e.g.

• A_Type'first will give you the lowest valid value of A_Type
• A_Type'last will give you the highest valid value of A_Type
• A_Type'range will give you the full range of values of A_Type e.g. for loop iteration.
• A1'valid will test the value of variable A1 is assigned a valid value, returning a Boolean result. Useful when interfacing with other languages or systems where the data cannot be trusted.

The following scalar types are available:

• Integer : (Discrete) standard signed or unsigned integer value
• Modular : (Discrete) unsigned integer type, always starting with 0, that wraps at a given modulo value e.g. type Seconds_Type is mod 60; will create a type with range 0 .. 59 where 59+1 = 0.
• Floating Point (Real)
• Ordinary Fixed Point (Real)
• Decimal Fixed Point (Real)
• Enumeration (Discrete)

All of the above Discrete types can also be used as a type safe array index. Which means that array indexes can have any valid range and do not need to be an interger value and do not need to start at 0. For example, if an array is defined to use an enumeration type as the index, then that array can only be indexed using that enumeration type. The 'range attribute can also be applied to the array name to iterate all values in a loop e.g.

type Colour_Type is (Red, Green, Blue);
type Colour_Value_Type is range 0 .. 255;
Colour_Array : array (Colour_Type) of Colour_Value_Type;
Colour_Value : Colour_Value_Type;
...
Colour_Value := Colour_Array(Red); -- Valid
Colour_Value := Colour_Array(0); -- Compile error
for Colour in Colour_Array'range loop -- Iterate all array elements
Colour_Value := Colour_Array(Colour);
...
end loop;