Enum TypeScheme 

pub enum TypeScheme<N: Name = &'static str> {
    Monotype(Type<N>),
    Polytype {
        variable: Variable,
        body: Box<TypeScheme<N>>,
    },
}

Represents polytypes (uninstantiated, universally quantified types).

The primary ways of creating a TypeScheme are with the ptp! macro or with Type::generalize.

Variants

Monotype(Type<N>)

Non-polymorphic types (e.g. α → β, int → bool)

Polytype

Polymorphic types (e.g. ∀α. α → α, ∀α. ∀β. α → β)

Fields

variable: Variable

The Variable being bound

body: Box<TypeScheme<N>>

The type in which variable is bound

Implementations

impl<N: Name> TypeScheme<N>

pub fn is_bound(&self, v: Variable) -> bool

Checks whether a variable is bound in the quantification of a polytype.

Examples

let t = ptp!(0; @arrow[tp!(0), tp!(1)]); // ∀α. α → β
assert!(t.is_bound(0));
assert!(!t.is_bound(1));

pub fn bound_vars(&self) -> Vec<Variable>

Returns a set of each Variable bound by the TypeScheme.

Examples

let t = ptp!(0, 1; @arrow[tp!(1), tp!(2), tp!(3)]); // ∀α. ∀β. β → ɣ → δ
assert_eq!(t.bound_vars(), vec![0, 1]);

pub fn free_vars(&self) -> Vec<Variable>

Returns a set of each free Variable in the TypeScheme.

Examples

let t = ptp!(0, 1; @arrow[tp!(1), tp!(2), tp!(3)]); // ∀α. ∀β. β → ɣ → δ
let mut free = t.free_vars();
free.sort();
assert_eq!(free, vec![2, 3]);

pub fn instantiate(&self, ctx: &mut Context<N>) -> Type<N>

Instantiate a TypeScheme in the context by removing quantifiers.

All type variables will be replaced with fresh type variables.

Examples

let mut ctx = Context::default();

let t1 = ptp!(3; list(tp!(3)));
let t2 = ptp!(3; list(tp!(3)));

let t1 = t1.instantiate(&mut ctx);
let t2 = t2.instantiate(&mut ctx);
assert_eq!(t1.to_string(), "list(t0)");
assert_eq!(t2.to_string(), "list(t1)");

pub fn instantiate_owned(self, ctx: &mut Context<N>) -> Type<N>

Like instantiate, but works in-place.

Trait Implementations

impl<N: Clone + Name> Clone for TypeScheme<N>

fn clone(&self) -> TypeScheme<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Name> Debug for TypeScheme<N>

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

Formats the value using the given formatter.

impl<N: Name> Display for TypeScheme<N>

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

Formats the value using the given formatter.

impl<N: Name> FromStr for TypeScheme<N>

fn from_str(s: &str) -> Result<TypeScheme<N>, ParseError>

Parse a TypeScheme from a string. This round-trips with Display. This is a leaky operation and should be avoided wherever possible: names of constructed types will remain until program termination.

The “for-all” ∀ is optional.

Examples

let t_par: TypeScheme = "∀t0. t0 -> t0".parse().expect("invalid type");
let t_lit = ptp!(0; @arrow[tp!(0), tp!(0)]);
assert_eq!(t_par, t_lit);

let s = "∀t0. ∀t1. (t1 → t0 → t1) → t1 → list(t0) → t1";
let t: TypeScheme<&'static str> = s.parse().expect("invalid type");
let round_trip = t.to_string();
assert_eq!(s, round_trip);

type Err = ParseError

The associated error which can be returned from parsing.

impl<N: Hash + Name> Hash for TypeScheme<N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<N: PartialEq + Name> PartialEq for TypeScheme<N>

fn eq(&self, other: &TypeScheme<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<N: Eq + Name> Eq for TypeScheme<N>

impl<N: Name> StructuralPartialEq for TypeScheme<N>