Enum erg_compiler::ty::free::Constraint

pub enum Constraint {
    Sandwiched {
        sub: Type,
        sup: Type,
    },
    TypeOf(Type),
    Uninited,
}

NOTE: you should use Free::get_type/get_subsup instead of deconstructing the constraint by match. Constraints may contain cycles, in which case using match to get the contents will cause memory pollutions. So this does not implement structural_eq.

Variants

Sandwiched

Fields

sub: Type

sup: Type

:> Sub, <: Sup

TypeOf(Type)

Uninited

Implementations

impl Constraint

pub const fn new_sandwiched(sub: Type, sup: Type) -> Self

:> Sub, <: Sup

pub fn named_fmt( &self, f: &mut Formatter<'_>, name: &str, limit: usize ) -> Result

pub fn new_type_of(t: Type) -> Self

pub const fn new_subtype_of(sup: Type) -> Self

pub const fn new_supertype_of(sub: Type) -> Self

pub const fn is_uninited(&self) -> bool

pub fn lift(&self)

pub fn get_type(&self) -> Option<&Type>

pub fn get_sub(&self) -> Option<&Type>

:> Sub

pub fn get_super(&self) -> Option<&Type>

<: Sup

pub fn get_sub_sup(&self) -> Option<(&Type, &Type)>

pub fn get_super_mut(&mut self) -> Option<&mut Type>

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Constraint

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

Formats the value using the given formatter.

impl Display for Constraint

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

Formats the value using the given formatter.

impl Hash for Constraint

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 LimitedDisplay for Constraint

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

impl PartialEq<Constraint> for Constraint

fn eq(&self, other: &Self) -> 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 Eq for Constraint