Struct arithmetic_typing::DynConstraints

pub struct DynConstraints<Prim: PrimitiveType> { /* private fields */ }

Arbitrary type implementing certain constraints. Similar to dyn _ types in Rust or use of interfaces in type position in TypeScript.

Constraints in this type must be object-safe. DynConstraints can also specify an Object constraint, which can be converted to it using the From trait.

Notation

• If the constraints do not include an object constraint, they are Displayed like a ConstraintSet with dyn prefix; e.g, dyn Lin + Hash.
• If the constraints include an object constraint, it is specified before all other constraints, but after the dyn prefix; e.g., dyn { x: Num } + Lin.

Examples

dyn _ types can be used to express that any types satisfying certain constraints should be accepted.

let code = "
    sum_lengths = |...pts: dyn { x: _, y: _ }| {
        pts.fold(0, |acc, { x, y }| acc + sqrt(x * x + y * y))
    };
    sum_lengths(#{ x: 1, y: 2 }, #{ x: 3, y: 4, z: 5 })
";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;

let mut env = TypeEnvironment::new();
let sqrt = Function::builder().with_arg(Type::NUM).returning(Type::NUM);
env.insert("fold", Prelude::Fold).insert("sqrt", sqrt);
env.process_statements(&ast)?;

assert_eq!(
    env["sum_lengths"].to_string(),
    "(...[dyn { x: Num, y: Num }; N]) -> Num"
);

One of primary use cases of dyn _ is restricting varargs of a function:

// Function that accepts any amount of linear args (not necessarily
// of the same type) and returns a number.
let digest_fn = Type::try_from(&TypeAst::try_from("(...[dyn Lin; N]) -> Num")?)?;
let mut env = TypeEnvironment::new();
env.insert("true", Prelude::True).insert("digest", digest_fn);

let code = "
    digest(1, 2, (3, 4), #{ x: 5, y: (6,) }) == 1;
    digest(3, true) == 0; // fails: `true` is not linear
";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;
let errors = env.process_statements(&ast).unwrap_err();

let err = errors.iter().next().unwrap();
assert_eq!(err.main_location().span(code), "true");
assert_matches!(err.kind(), ErrorKind::FailedConstraint { .. });

Implementations

impl<Prim: PrimitiveType> DynConstraints<Prim>

pub fn just(constraint: impl ObjectSafeConstraint<Prim>) -> Self

Creates constraints based on a single constraint.

pub fn is_empty(&self) -> bool

Checks if this constraint set is empty.

pub fn object(&self) -> Option<&Object<Prim>>

Returns the enclosed object constraint, if any.

pub fn insert(&mut self, constraint: impl ObjectSafeConstraint<Prim>)

Adds the specified constraint to these constraints.

Trait Implementations

impl<Prim: Clone + PrimitiveType> Clone for DynConstraints<Prim>

fn clone(&self) -> DynConstraints<Prim>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Prim: PrimitiveType> Debug for DynConstraints<Prim>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Prim: PrimitiveType> Display for DynConstraints<Prim>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Prim: PrimitiveType> From<DynConstraints<Prim>> for Type<Prim>

fn from(constraints: DynConstraints<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PrimitiveType> From<Object<Prim>> for DynConstraints<Prim>

fn from(object: Object<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PartialEq + PrimitiveType> PartialEq for DynConstraints<Prim>

fn eq(&self, other: &DynConstraints<Prim>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Prim: PrimitiveType> StructuralPartialEq for DynConstraints<Prim>