Enum TypeF 

pub enum TypeF<Ty, RRows, ERows, Te> {
    Dyn,
    Number,
    Bool,
    String,
    Symbol,
    ForeignId,
    Contract(Te),
    Arrow(Ty, Ty),
    Var(Ident),
    Forall {
        var: LocIdent,
        var_kind: VarKind,
        body: Ty,
    },
    Enum(ERows),
    Record(RRows),
    Dict {
        type_fields: Ty,
        flavour: DictTypeFlavour,
    },
    Array(Ty),
    Wildcard(usize),
}

A Nickel type.

Generic representation (functor)

A Nickel type is represented by a tree and is naturally defined in a recursive manner: for example, one would expect the constructor for function types (Arrow) to look like:

pub enum Type {
     Arrow(Box<Type>, Box<Type>),
     // ...
}

However, TypeF is slightly different, in that it is parametrized by a generic type instead of using a concrete definition like Box<Types> (forget about rows for now):

pub enum TypeF<Ty /* , .. */> {
     Arrow(Ty, Ty),
     // ...
}

Ty is also called a recursive unfolding throughout the documentation. By defining struct Type(TypeF<Box<Types>>), we get back the original, natural definition.

Motivation 1: variation on Types

Having a generic definition makes it possible to easily create other types with the same shape as Type (seen as trees), but with enriched nodes. The typical use-case in Nickel is the variation on types used by the typechecker. During type inference, the typechecker operates on trees where each node can either be a concrete type, or a unification variable (a unknown type to be inferred). Instead of duplicating the whole definition of Type as well as all basic methods, we can simply have a different recursive definition:

pub enum UnifType {
   UnifVar(VarId),
   Concrete(TypeF<Box<UnifType> /*, .. */>),
   // ..
 }

We get something that looks like normal Nickel types, except that each node can also be a unification variable as well.

Motivation 2: recursion schemes

This definition is actually in the style of recursion schemes. Pedantically, TypeF (hence the F suffix) is a functor, but the formal details aren’t so important: keep in mind that the F suffix means that the recursive occurrences of subtrees (and enum rows and record rows as well) are replaced by generic parameters.

The usual motivation for recursion schemes is that they allow for elegant and simple definitions of recursive transformation over trees (here, TypeF, and more generally anything with an F suffix) in terms of simple appropriate chaining of map and folding/unfolding operations. A good example is the definition of crate::ast::typ::Type::traverse. Although crate::ast::Node isn’t currently defined using functors per se, the way program transformations are written is in the same style as recursion schemes: we simply define the action of a transformation as a mapping on the current node, and let the traversal take care of the plumbing of recursion and reconstruction.

Type parameters

• Ty: the recursive unfolding of Nickel types
• RRows: the recursive unfolding of record rows
• ERows: the recursive unfolding of enum rows
• Te: the type of a term (used to store contracts)

Variants

Dyn

The dynamic type, or unitype. Assigned to values whose actual type is not statically known or checked.

Number

A floating point number.

Bool

A boolean.

String

A string literal.

Symbol

A symbol.

See Term::Sealed in nickel_lang_core.

ForeignId

The type of Term::ForeignId.

Contract(Te)

A type created from a user-defined contract.

Arrow(Ty, Ty)

A function.

Var(Ident)

A type variable.

Forall

A forall binder.

Fields

var: LocIdent

var_kind: VarKind

body: Ty

Enum(ERows)

An enum type, composed of a sequence of enum rows.

Record(RRows)

A record type, composed of a sequence of record rows.

Dict

A dictionary type.

Fields

type_fields: Ty

flavour: DictTypeFlavour

Array(Ty)

A parametrized array.

Wildcard(usize)

A type wildcard, wrapping an ID unique within a given file.

Implementations

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

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

impl<Ty, RRows, ERows, Te> TypeF<Ty, RRows, ERows, Te>

pub fn try_map_state<TyO, RRowsO, ERowsO, TeO, FTy, FRRows, FERows, FTe, S, E>( self, f: FTy, f_rrows: FRRows, f_erows: FERows, f_ctr: FTe, state: &mut S, ) -> Result<TypeF<TyO, RRowsO, ERowsO, TeO>, E>

where FTy: FnMut(Ty, &mut S) -> Result<TyO, E>, FRRows: FnMut(RRows, &mut S) -> Result<RRowsO, E>, FERows: FnMut(ERows, &mut S) -> Result<ERowsO, E>, FTe: FnMut(Te, &mut S) -> Result<TeO, E>,

Map functions over the children nodes of a type, when seen as a tree. The mutable state ( S) is threaded through the calls to the mapped functions. Functions are fallible and may return an error E, which causes try_map_state to return early with the same error.

If we put aside the state and the error (see [RecordRowsF::map), this function makes TypeF a functor (of arity 3). As hinted by the type signature, this function just maps on “one-level” of recursion, so to speak.

Take the instantiated version Type, and a type of the form (Dyn -> Dyn) -> (Number -> Dyn). Then, calling try_map_state(f_ty, ..) on this type rows will map f_ty onto (Dyn -> Dyn) and Number -> Dyn because they are direct children of the root Arrow node.

Note that f_ty isn’t mapped onto Dyn and Number recursively: map isn’t a recursive operation. It’s however a building block to express recursive operations: as an example, see crate::ast::typ::RecordRows::traverse.

Since TypeF may contain record rows and enum rows as well, f_rrows and f_erows are required to know how to map on record and enum types respectively.

pub fn try_map<TyO, RRowsO, ERowsO, TeO, FTy, FRRows, FERows, FTe, E>( self, f: FTy, f_rrows: FRRows, f_erows: FERows, f_ctr: FTe, ) -> Result<TypeF<TyO, RRowsO, ERowsO, TeO>, E>

where FTy: FnMut(Ty) -> Result<TyO, E>, FRRows: FnMut(RRows) -> Result<RRowsO, E>, FERows: FnMut(ERows) -> Result<ERowsO, E>, FTe: FnMut(Te) -> Result<TeO, E>,

Variant of try_map_state without threaded state.

pub fn map_state<TyO, RRowsO, ERowsO, TeO, FTy, FRRows, FERows, FTe, S>( self, f: FTy, f_rrows: FRRows, f_erows: FERows, f_ctr: FTe, state: &mut S, ) -> TypeF<TyO, RRowsO, ERowsO, TeO>

where FTy: FnMut(Ty, &mut S) -> TyO, FRRows: FnMut(RRows, &mut S) -> RRowsO, FERows: FnMut(ERows, &mut S) -> ERowsO, FTe: FnMut(Te, &mut S) -> TeO,

Variant of try_map_state with infallible functions.

pub fn map<TyO, RRowsO, ERowsO, TeO, FTy, FRRows, FERows, FTe>( self, f: FTy, f_rrows: FRRows, f_erows: FERows, f_ctr: FTe, ) -> TypeF<TyO, RRowsO, ERowsO, TeO>

where FTy: FnMut(Ty) -> TyO, FRRows: FnMut(RRows) -> RRowsO, FERows: FnMut(ERows) -> ERowsO, FTe: FnMut(Te) -> TeO,

Variant of try_map_state without threaded state and with infallible functions.

pub fn is_wildcard(&self) -> bool

pub fn is_contract(&self) -> bool

Trait Implementations

impl<Ty: Clone, RRows: Clone, ERows: Clone, Te: Clone> Clone for TypeF<Ty, RRows, ERows, Te>

fn clone(&self) -> TypeF<Ty, RRows, ERows, Te>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Ty, RRows, ERows, Te> CloneTo for TypeF<Ty, RRows, ERows, Te>

where Ty: CloneTo, RRows: CloneTo, ERows: CloneTo, Te: CloneTo,

type Data<'a> = TypeF<<Ty as CloneTo>::Data<'a>, <RRows as CloneTo>::Data<'a>, <ERows as CloneTo>::Data<'a>, <Te as CloneTo>::Data<'a>>

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<Ty: Debug, RRows: Debug, ERows: Debug, Te: Debug> Debug for TypeF<Ty, RRows, ERows, Te>

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<Ty: PartialEq, RRows: PartialEq, ERows: PartialEq, Te: PartialEq> PartialEq for TypeF<Ty, RRows, ERows, Te>

fn eq(&self, other: &TypeF<Ty, RRows, ERows, Te>) -> 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<Ty: Eq, RRows: Eq, ERows: Eq, Te: Eq> Eq for TypeF<Ty, RRows, ERows, Te>

impl<Ty, RRows, ERows, Te> StructuralPartialEq for TypeF<Ty, RRows, ERows, Te>