Struct lark_ty::Ty

pub struct Ty<F: TypeFamily> {
    pub repr: F::Repr,
    pub perm: F::Perm,
    pub base: F::Base,
}

A type is the combination of a permission and a base type.

Fields

repr: F::Repr

perm: F::Perm

base: F::Base

Trait Implementations

impl<S, T> Map<S, T> for Ty<S> where
    S: TypeFamily,
    T: TypeFamily, 

type Output = Ty<T>

fn map(
    &self,
    mapper: &mut impl FamilyMapper<S, T>
) -> Self::Output

impl<F: Eq + TypeFamily> Eq for Ty<F> where
    F::Repr: Eq,
    F::Perm: Eq,
    F::Base: Eq, 

impl<F: Clone + TypeFamily> Clone for Ty<F> where
    F::Repr: Clone,
    F::Perm: Clone,
    F::Base: Clone, 

fn clone(&self) -> Ty<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Copy + TypeFamily> Copy for Ty<F> where
    F::Repr: Copy,
    F::Perm: Copy,
    F::Base: Copy, 

impl<F: PartialEq + TypeFamily> PartialEq<Ty<F>> for Ty<F> where
    F::Repr: PartialEq,
    F::Perm: PartialEq,
    F::Base: PartialEq, 

fn eq(&self, other: &Ty<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Ty<F>) -> bool

This method tests for !=.

impl<F: Hash + TypeFamily> Hash for Ty<F> where
    F::Repr: Hash,
    F::Perm: Hash,
    F::Base: Hash, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<F: Debug + TypeFamily> Debug for Ty<F> where
    F::Repr: Debug,
    F::Perm: Debug,
    F::Base: Debug, 

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

Formats the value using the given formatter.

impl<F: TypeFamily + DebugWith> DebugWith for Ty<F>

fn fmt_with<Cx: ?Sized>(&self, cx: &Cx, fmt: &mut Formatter) -> Result

fn debug_with<Cx>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, &'me Self, Cx> where
    Cx: ?Sized, 

fn into_debug_with<Cx>(self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> where
    Cx: ?Sized, 

impl<DB, F, '_> ErrorSentinel<&'_ DB> for Ty<F> where
    DB: AsRef<F::InternTables>,
    F: TypeFamily, 

fn error_sentinel(db: &DB, _report: ErrorReported) -> Self