Struct arithmetic_typing::TypeEnvironment

source ·

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

Expand description

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§

source §

impl<Prim: PrimitiveType> TypeEnvironment<Prim>

source

pub fn new() -> Self

Creates an empty environment.

source

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

Gets type of the specified variable.

source

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

Iterates over variables contained in this env.

source

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.

source

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.

source

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.

source

pub fn process_statements<'a, T>( &mut self, block: &Block<'a, T> ) -> Result<Type<Prim>, Errors<Prim>>where T: Grammar<Type<'a> = 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().

source

pub fn process_with_arithmetic<'a, T, A>( &mut self, arithmetic: &A, block: &Block<'a, T> ) -> Result<Type<Prim>, Errors<Prim>>where T: Grammar<Type<'a> = 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.