Struct Type 

pub struct Type<'ast> {
    pub typ: TypeUnr<'ast>,
    pub pos: TermPos,
}

Concrete, recursive type for a Nickel type.

Fields

typ: TypeUnr<'ast>

pos: TermPos

Implementations

impl<'ast> Type<'ast>

pub fn with_pos(self, pos: TermPos) -> Type<'ast>

Sets a new position for this type.

pub fn find_contract(&'ast self) -> Option<&'ast Ast<'ast>>

Searches for a crate::typ::TypeF. If one is found, returns the term it contains.

Trait Implementations

impl<'ast> Clone for Type<'ast>

fn clone(&self) -> Type<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for Type<'_>

type Data<'ast> = Type<'ast>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(data: Self::Data<'_>, dest: &'to AstAlloc) -> Self::Data<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Debug for Type<'ast>

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

Formats the value using the given formatter.

impl Display for Type<'_>

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

Formats the value using the given formatter.

impl<'ast> From<TypeF<&'ast Type<'ast>, RecordRows<'ast>, EnumRows<'ast>, &'ast Ast<'ast>>> for Type<'ast>

fn from(typ: TypeUnr<'ast>) -> Self

Converts to this type from the input type.

impl IsAtom for Type<'_>

fn is_atom(&self) -> bool

Determine if an expression is an atom of the surface syntax. Atoms are basic elements of the syntax that can freely substituted without being parenthesized.

impl<'ast> PartialEq for Type<'ast>

fn eq(&self, other: &Type<'ast>) -> 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<'a> Pretty<'a, Allocator> for &Type<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl<'ast> TraverseAlloc<'ast, Ast<'ast>> for Type<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Self, E>

where F: FnMut(Ast<'ast>) -> Result<Ast<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Ast<'ast>, &S) -> TraverseControl<S, U>, state: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl<'ast> TraverseAlloc<'ast, Type<'ast>> for Ast<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Ast<'ast>, E>

where F: FnMut(Type<'ast>) -> Result<Type<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Type<'ast>, &S) -> TraverseControl<S, U>, state: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl<'ast> TraverseAlloc<'ast, Type<'ast>> for RecordRows<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<RecordRows<'ast>, E>

where F: FnMut(Type<'ast>) -> Result<Type<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Type<'ast>, &S) -> TraverseControl<S, U>, state: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl<'ast> TraverseAlloc<'ast, Type<'ast>> for Type<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Self, E>

where F: FnMut(Type<'ast>) -> Result<Type<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Type<'ast>, &S) -> TraverseControl<S, U>, state: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl Allocable for Type<'_>

impl<'ast> Eq for Type<'ast>

impl<'ast> StructuralPartialEq for Type<'ast>