Struct arithmetic_typing::arith::StructConstraint

pub struct StructConstraint<Prim, C, F> { /* fields omitted */ }

Helper to define structural Constraints, i.e., constraints recursively checking the provided type.

The following logic is used to check whether a type satisfies the constraint:

• Primitive types satisfy the constraint iff the predicate provided in Self::new() returns true.
• Type::Any always satisfies the constraint.
• Type::Dyn types satisfy the constraint iff the Constraint wrapped by this helper is present among DynConstraints. Thus, if the wrapped constraint is not object-safe, it will not be satisfied by any Dyn type.
• Functional types never satisfy the constraint.
• A compound type (i.e., a tuple) satisfies the constraint iff all its items satisfy the constraint.
• If Self::deny_dyn_slices() is set, tuple types need to have static length.

Examples

Defining a constraint type using StructConstraint:

/// Constraint for hashable types.
#[derive(Clone, Copy)]
struct Hashed;

impl fmt::Display for Hashed {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str("Hash")
    }
}

impl<Prim: PrimitiveType> Constraint<Prim> for Hashed {
    fn visitor<'r>(
        &self,
        substitutions: &'r mut Substitutions<Prim>,
        errors: OpErrors<'r, Prim>,
    ) -> Box<dyn Visit<Prim> + 'r> {
        // We can hash everything except for functions (and thus,
        // types containing functions).
        StructConstraint::new(*self, |_| true)
            .visitor(substitutions, errors)
    }

    fn clone_boxed(&self) -> Box<dyn Constraint<Prim>> {
        Box::new(*self)
    }
}

Implementations

impl<Prim, C, F> StructConstraint<Prim, C, F> where
    Prim: PrimitiveType,
    C: Constraint<Prim> + Clone,
    F: Fn(&Prim) -> bool + 'static, 

pub fn new(constraint: C, predicate: F) -> Self

Creates a new helper. predicate determines whether a particular primitive type should satisfy the constraint.

pub fn deny_dyn_slices(self) -> Self

Marks that dynamically sized slices should fail the constraint check.

pub fn visitor<'r>(
    self,
    substitutions: &'r mut Substitutions<Prim>,
    errors: OpErrors<'r, Prim>
) -> Box<dyn Visit<Prim> + 'r>

Returns a Visitor that can be used for Constraint::visitor() implementations.

Trait Implementations

impl<Prim: Debug, C: Debug, F: Debug> Debug for StructConstraint<Prim, C, F>

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

Formats the value using the given formatter.