Enum nessa::types::Type

pub enum Type {
    Empty,
    InferenceMarker,
    SelfType,
    Basic(usize),
    Ref(Box<Type>),
    MutRef(Box<Type>),
    Or(Vec<Type>),
    And(Vec<Type>),
    Wildcard,
    TemplateParam(usize, Vec<InterfaceConstraint>),
    TemplateParamStr(String, Vec<InterfaceConstraint>),
    Template(usize, Vec<Type>),
    Function(Box<Type>, Box<Type>),
}

Variants

Empty

InferenceMarker

SelfType

Basic(usize)

Ref(Box<Type>)

MutRef(Box<Type>)

Or(Vec<Type>)

And(Vec<Type>)

Wildcard

TemplateParam(usize, Vec<InterfaceConstraint>)

TemplateParamStr(String, Vec<InterfaceConstraint>)

Template(usize, Vec<Type>)

Function(Box<Type>, Box<Type>)

Implementations

impl Type

pub fn is_ref(&self) -> bool

pub fn to_ref(self) -> Type

pub fn to_mut(self) -> Type

pub fn or(self, other: Type) -> Type

pub fn deref_type(&self) -> &Type

pub fn get_name(&self, ctx: &NessaContext) -> String

pub fn get_name_plain(&self, ctx: &NessaContext) -> String

pub fn has_templates(&self) -> bool

pub fn has_self(&self) -> bool

pub fn template_dependencies(&self, templates: &mut HashSet<usize>)

pub fn type_dependencies(&self) -> Vec<usize>

pub fn interface_dependencies(&self) -> Vec<usize>

pub fn bindable_to(&self, other: &Type, ctx: &NessaContext) -> bool

pub fn bindable_to_subtitutions( &self, other: &Type, ctx: &NessaContext ) -> (bool, HashMap<usize, Type>)

pub fn bindable_to_template( &self, other: &Type, templates: &[Type], ctx: &NessaContext ) -> bool

pub fn template_bindable_to( &self, other: &Type, t_assignments: &mut HashMap<usize, Type>, t_deps: &mut HashMap<usize, HashSet<usize>>, ctx: &NessaContext ) -> bool

pub fn compile_templates(&mut self, templates: &Vec<String>)

pub fn offset_templates(&mut self, offset: usize)

pub fn max_template(&self) -> i32

pub fn sub_templates(&self, args: &HashMap<usize, Type>) -> Type

pub fn sub_templates_rec(&self, args: &HashMap<usize, Type>, rec: i32) -> Type

pub fn sub_self(&self, sub: &Type) -> Type

pub fn map_type( &self, ctx: &mut NessaContext, other_ctx: &NessaContext, id_mapper: &mut IdMapper, l: &Location ) -> Type

pub fn map_basic_types( &self, mapping: &mut impl FnMut(usize) -> Result<usize, String> ) -> Type

pub fn map_interfaces( &self, mapping: &mut impl FnMut(usize) -> Result<usize, String> ) -> Type

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Type

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 PartialEq for Type

fn eq(&self, b: &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 Serialize for Type

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Type