Struct arithmetic_typing::Object

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

Object type: a collection of named fields with heterogeneous types.

Notation

Object types are denoted using a brace notation such as { x: Num, y: [(Num, 'T)] }. Here, x and y are field names, and Num / [(Num, 'T)] are types of the corresponding object fields.

As constraint

Object types are exact; their extensions cannot be unified with the original types. For example, if a function argument is { x: Num, y: Num }, the function cannot be called with an arg of type { x: Num, y: Num, z: Num }:

let code = "
    sum_coords = |pt: { x: Num, y: Num }| pt.x + pt.y;
    sum_coords(#{ x: 3, y: 4 }); // OK
    sum_coords(#{ x: 3, y: 4, z: 5 }); // fails
";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;
let err = TypeEnvironment::new().process_statements(&ast).unwrap_err();
let err = err.iter().next().unwrap();
assert_matches!(err.kind(), ErrorKind::FieldsMismatch { .. });

To bridge this gap, objects can be used as a constraint on types, similarly to Constraints. As a constraint, an object specifies necessary fields, which can be arbitrarily extended.

The type inference algorithm uses object constraints, not concrete object types whenever possible:

let code = "
    sum_coords = |pt| pt.x + pt.y;
    sum_coords(#{ x: 3, y: 4 }); // OK
    sum_coords(#{ x: 3, y: 4, z: 5 }); // also OK
";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;
let mut env = TypeEnvironment::new();
env.process_statements(&ast)?;
assert_eq!(
    env["sum_coords"].to_string(),
    "for<'T: { x: 'U, y: 'U }, 'U: Ops> ('T) -> 'U"
);

Note that the object constraint in this case refers to another type param, which is constrained on its own!

Implementations

impl<Prim: PrimitiveType> Object<Prim>

pub fn new() -> Self

Creates an empty object.

pub fn get(&self, name: &str) -> Option<&Type<Prim>>

Returns type of a field with the specified name.

pub fn iter(&self) -> impl Iterator<Item = (&str, &Type<Prim>)> + '_

Iterates over fields in this object.

pub fn field_names(&self) -> impl Iterator<Item = &str> + '_

Iterates over field names in this object.

pub fn into_dyn(self) -> Type<Prim>

Converts this object into a corresponding dynamic constraint.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Prim: Debug + PrimitiveType> Debug for Object<Prim>

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

Formats the value using the given formatter.

impl<Prim: PrimitiveType> Default for Object<Prim>

fn default() -> Self

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

impl<Prim, S, V, const N: usize> From<[(S, V); N]> for Object<Prim>

where Prim: PrimitiveType, S: Into<String>, V: Into<Type<Prim>>,

fn from(entries: [(S, V); N]) -> 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: PrimitiveType> From<Object<Prim>> for Type<Prim>

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

Converts to this type from the input type.

impl<Prim, S, V> FromIterator<(S, V)> for Object<Prim>

where Prim: PrimitiveType, S: Into<String>, V: Into<Type<Prim>>,

fn from_iter<T: IntoIterator<Item = (S, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<Prim: PrimitiveType> Index<&str> for Object<Prim>

type Output = Type<Prim>

The returned type after indexing.

fn index(&self, field_name: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

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

fn eq(&self, other: &Object<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 Object<Prim>