Enum mun_hir::TyKind

pub enum TyKind {
    Struct(Struct),
    Float(FloatTy),
    Int(IntTy),
    Bool,
    Tuple(usize, Substitution),
    InferenceVar(InferTy),
    TypeAlias(TypeAlias),
    Never,
    FnDef(CallableDef, Substitution),
    Array(Ty),
    Unknown,
}

A kind of type.

Variants

Struct(Struct)

An abstract datatype (structures, tuples, or enumerations) TODO: Add enumerations

Float(FloatTy)

The primitive floating point type. Written as float.

Int(IntTy)

The primitive integral type. Written as int.

Bool

The primitive boolean type. Written as bool.

Tuple(usize, Substitution)

A tuple type. For example (f32, f64, bool).

InferenceVar(InferTy)

A type variable used during type checking. Not to be confused with a type parameter.

TypeAlias(TypeAlias)

A type alias

Never

The never type never.

FnDef(CallableDef, Substitution)

The anonymous type of a function declaration/definition. Each function has a unique type, which is output (for a function named foo returning an number) as fn() -> number {foo}.

This includes tuple struct / enum variant constructors as well.

For example the type of bar here:

function foo() -> number { 1 }
let bar = foo; // bar: function() -> number {foo}

Array(Ty)

An dynamically sized array type

Unknown

A placeholder for a type which could not be computed; this is propagated to avoid useless error messages. Doubles as a placeholder where type variables are inserted before type checking, since we want to try to infer a better type here anyway – for the IDE use case, we want to try to infer as much as possible even in the presence of type errors.

Implementations

impl TyKind

pub fn intern(self) -> Ty

Constructs a new Ty by interning self

Trait Implementations

impl Clone for TyKind

fn clone(&self) -> TyKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TyKind

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

Formats the value using the given formatter.

impl HasVisibility for TyKind

fn visibility(&self, db: &dyn HirDatabase) -> Visibility

impl Hash for TyKind

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<TyKind> for TyKind

fn eq(&self, other: &TyKind) -> 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 TyKind

impl StructuralEq for TyKind

impl StructuralPartialEq for TyKind