Enum RecordRowsF 

pub enum RecordRowsF<Ty, RRows> {
    Empty,
    Extend {
        row: RecordRowF<Ty>,
        tail: RRows,
    },
    TailVar(LocIdent),
    TailDyn,
}

Generic sequence of record rows potentially with a type variable or Dyn in tail position.

As other types with the F suffix, this type is parametrized by one or more recursive unfoldings. See TypeF for more details.

Type parameters

• Ty is the recursive unfolding of a Nickel type stored inside one row. In practice, a wrapper around an instantiation of TypeF.
• RRows is the recursive unfolding of record rows (the tail of this row sequence). In practice, a wrapper around an instantiation of RecordRowsF.

Variants

Empty

Extend

Fields

row: RecordRowF<Ty>

tail: RRows

TailVar(LocIdent)

TailDyn

Implementations

impl<Ty, RRows> RecordRowsF<Ty, RRows>

pub fn try_map_state<TyO, RRowsO, FTy, FRRows, S, E>( self, f_ty: FTy, f_rrows: FRRows, state: &mut S, ) -> Result<RecordRowsF<TyO, RRowsO>, E>

where FTy: FnMut(Ty, &mut S) -> Result<TyO, E>, FRRows: FnMut(RRows, &mut S) -> Result<RRowsO, E>,

Map functions over the children nodes of record rows, 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 RecordRowsF a functor (of arity 2). As hinted by the type signature, this function just maps on “one-level” of recursion, so to speak. Take the instantiated version RecordRows, and record rows of the form {foo : T, bar: U, baz: V}. Then, calling try_map_state(f_ty, f_rrows, state) on these rows will map f_ty onto T and f_rrows onto {bar : U, baz: V}.

Note that f_ty isn’t mapped onto U and V 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.

pub fn try_map<TyO, RRowsO, FTy, FRRows, E>( self, f_ty: FTy, f_rrows: FRRows, ) -> Result<RecordRowsF<TyO, RRowsO>, E>

where FTy: FnMut(Ty) -> Result<TyO, E>, FRRows: FnMut(RRows) -> Result<RRowsO, E>,

Variant of try_map_state without threaded state.

pub fn map_state<TyO, RRowsO, FTy, FRRows, S>( self, f_ty: FTy, f_rrows: FRRows, state: &mut S, ) -> RecordRowsF<TyO, RRowsO>

where FTy: FnMut(Ty, &mut S) -> TyO, FRRows: FnMut(RRows, &mut S) -> RRowsO,

Variant of try_map_state with infallible functions.

pub fn map<TyO, RRowsO, FTy, FRRows>( self, f_ty: FTy, f_rrows: FRRows, ) -> RecordRowsF<TyO, RRowsO>

where FTy: FnMut(Ty) -> TyO, FRRows: FnMut(RRows) -> RRowsO,

Variant of try_map_state without threaded state and with infallible functions.

Trait Implementations

impl<Ty: Clone, RRows: Clone> Clone for RecordRowsF<Ty, RRows>

fn clone(&self) -> RecordRowsF<Ty, RRows>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Ty: CloneTo, RRows: CloneTo> CloneTo for RecordRowsF<Ty, RRows>

type Data<'ast> = RecordRowsF<<Ty as CloneTo>::Data<'ast>, <RRows as CloneTo>::Data<'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<Ty: Debug, RRows: Debug> Debug for RecordRowsF<Ty, RRows>

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

Formats the value using the given formatter.

impl<Ty: PartialEq, RRows: PartialEq> PartialEq for RecordRowsF<Ty, RRows>

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

impl<Ty, RRows> StructuralPartialEq for RecordRowsF<Ty, RRows>