Struct TypeEnvironment

pub struct TypeEnvironment<Prim: PrimitiveType = Num> { /* private fields */ }

Environment containing type information on named variables.

Examples

See the crate docs for examples of usage.

Concrete and partially specified types

The environment retains full info on the types even if the type is not concrete. Non-concrete types are tied to an environment. An environment will panic on inserting a non-concrete type via Self::insert() or other methods.

// An easy way to get a non-concrete type is to involve `any`.
let code = "(x, ...) = (1, 2, 3) as any;";
let code = Parser::parse_statements(code)?;

let mut env: TypeEnvironment = Prelude::iter().collect();
env.process_statements(&code)?;
assert!(!env["x"].is_concrete());

Implementations

impl<Prim: PrimitiveType> TypeEnvironment<Prim>

pub fn new() -> Self

Creates an empty environment.

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

Gets type of the specified variable.

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

Iterates over variables contained in this env.

pub fn insert(&mut self, name: &str, ty: impl Into<Type<Prim>>) -> &mut Self

Sets type of a variable.

Panics

• Will panic if ty is not concrete. Non-concrete types are tied to the environment; inserting them into an env is a logical error.

pub fn insert_constraint( &mut self, constraint: impl Constraint<Prim>, ) -> &mut Self

Inserts a Constraint into the environment so that it can be used when parsing type annotations.

Adding a constraint is not mandatory for it to be usable during type inference; this method only influences whether the constraint is recognized during type parsing.

pub fn insert_object_safe_constraint( &mut self, constraint: impl ObjectSafeConstraint<Prim>, ) -> &mut Self

Inserts an ObjectSafeConstraint into the environment so that it can be used when parsing type annotations.

Other than more strict type requirements, this method is identical to Self::insert_constraint.

pub fn process_statements<'a, T>( &mut self, block: &Block<'a, T>, ) -> Result<Type<Prim>, Errors<'a, Prim>>

where T: Grammar<'a, Type = TypeAst<'a>>, NumArithmetic: MapPrimitiveType<T::Lit, Prim = Prim> + TypeArithmetic<Prim>,

Processes statements with the default type arithmetic. After processing, the environment will contain type info about newly declared vars.

This method is a shortcut for calling process_with_arithmetic with NumArithmetic::without_comparisons().

pub fn process_with_arithmetic<'a, T, A>( &mut self, arithmetic: &A, block: &Block<'a, T>, ) -> Result<Type<Prim>, Errors<'a, Prim>>

where T: Grammar<'a, Type = TypeAst<'a>>, A: MapPrimitiveType<T::Lit, Prim = Prim> + TypeArithmetic<Prim>,

Processes statements with a given arithmetic. After processing, the environment will contain type info about newly declared vars.

Errors

Even if there are any type errors, all statements in the block will be executed to completion and all errors will be reported. However, the environment will not include any vars beyond the first failing statement.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<Prim: PrimitiveType, S, Ty> Extend<(S, Ty)> for TypeEnvironment<Prim>

where S: Into<String>, Ty: Into<Type<Prim>>,

fn extend<I: IntoIterator<Item = (S, Ty)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Prim: PrimitiveType, S, Ty> FromIterator<(S, Ty)> for TypeEnvironment<Prim>

where S: Into<String>, Ty: Into<Type<Prim>>,

fn from_iter<I: IntoIterator<Item = (S, Ty)>>(iter: I) -> Self

Creates a value from an iterator.

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

type Output = Type<Prim>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.