Is there a way to create a data type that only accepts a range of values?

by

As I understand it, that requires dependent types, which Rust does not have. This doesn’t require dependent types (see comments) but Rust still doesn’t have the support needed.

As a workaround, you could create a newtype that you verify yourself:

#[derive(Debug)]
struct Age(u16);

impl Age {
    fn new(age: u16) -> Option<Age> {
        if age <= 100 {
            Some(Age(age))
        } else {
            None
        }
    }
}

fn main() {
    let age1 = Age::new(30);
    let age2 = Age::new(500);

    println!("{:?}, {:?}", age1, age2);
    assert_eq!(
        std::mem::size_of::<Age>(),
        std::mem::size_of::<u16>()
    );
}

Of course, it doesn’t behave exactly like a u16, but you don’t want it to, either! For example, a u16 can go beyond 100… You’d have to reason out if it makes sense to add/subtract/multiply/divide etc your new type as well.

For maximum safeguarding, you should move your type and any associated functions into a module. This leverages Rust’s visibility rules to prevent people from accidentally accessing the value inside the newtype and invalidating the constraints.

You may also want to implement TryFrom (from u16 to your type) or From (from your type to u16) to better integrate with generic code.

An important thing to note is that this newtype takes the same amount of space as a u16 – the wrapper type is effectively erased when the code is compiled. The type checker makes sure everything meshes before that point.

More Related Contents:

  1. When is it appropriate to use an associated type versus a generic type?
  2. How do I print the type of a variable?
  3. Why can’t Rust infer the resulting type of Iterator::sum?
  4. Converting number primitives (i32, f64, etc) to byte representations
  5. How do I print in Rust the type of a variable?
  6. How to idiomatically convert between u32 and usize?
  7. biggest integer that can be stored in a double
  8. Which is the first integer that an IEEE 754 float is incapable of representing exactly?
  9. How can I have a collection of objects that differ by their associated type?
  10. JAXB: How to change XJC-generated classes names when attr type is specified in XSD?
  11. Is there a way to convert integers to bools in go or vice versa?
  12. Python method-wrapper type?
  13. How to create a circularly referenced type in TypeScript?
  14. golang type assertion using reflect.Typeof()
  15. Why can I type alias functions and use them without casting?
  16. Ensure a type implements an interface at compile time in Go
  17. Why IEEE754 single-precision float has only 7 digit precision?
  18. Defining TypeScript callback type
  19. Check if a value is an object in JavaScript
  20. Why is a trait not implemented for a type that clearly has it implemented?
  21. What makes something a “trait object”?
  22. Change enum variant while moving the field to the new variant
  23. Is string a value type or a reference type?
  24. Correct format specifier for return value of sizeof() in C
  25. .NET : How do you get the Type of a null object?
  26. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  27. Scala String vs java.lang.String – type inference
  28. What to do when bit mask (flags) enum gets too large
  29. List is a raw type. References to generic type List should be parameterized
  30. Can a struct containing a raw pointer implement Send and be FFI safe?

Leave a Comment