Struct kul_core::parser::premade::PairOperatorBindings

pub struct PairOperatorBindings<P, DA, OR, AR, CE> where
    P: Borrow<[(Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>)]>,
    DA: DatumAllocator,  {
    pub pairs: P,
    // some fields omitted
}

An OperatorBindings that associates generic Datums with generic Combiners, using a slice of pairs (2-tuples) of them.

The Datum values represent parsed operator sub-forms (of non-empty nest forms) that are bound to macro functions represented by the Combiner values.

You are responsible for initializing the slice with the desired bindings, and it may be dynamically mutated inbetween parser invocations, if desired and if you use a mutable type for it.

Fields

pairs: P

The bindings of operators to macros. You must initialize and manage this yourself.

Methods

impl<P, DA, OR, AR, CE> PairOperatorBindings<P, DA, OR, AR, CE> where
    P: Borrow<[(Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>)]>,
    DA: DatumAllocator, 

pub fn new(pairs: P) -> Self

Given a value of a type that can borrow as a slice of pairs (2-tuples) of Datums with Combiners, make a new instance of Self that uses it for its bindings.

Trait Implementations

impl<P, DA, OR, AR, CE> OperatorBindings<DA> for PairOperatorBindings<P, DA, OR, AR, CE> where
    P: Borrow<[(Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>)]>,
    DA: DatumAllocator,
    Datum<DA::TT, DA::ET, DA::DR>: PartialEq,
    OR: Deref<Target = OpFn<DA, CE>>,
    AR: Deref<Target = ApFn<DA, CE>>, 

type OR = OR

The type of references to Operative macro functions.

type AR = AR

The type of references to Applicative macro functions.

type CE = CE

The combiner error extension type.

fn lookup(
    &self,
    operator: &Datum<DA::TT, DA::ET, DA::DR>
) -> Option<&Combiner<OR, AR>>

Look-up any binding we might have associated with the given datum, referenced by the operator argument, which was found in operator (first, "head") position of a nested form. If we do have a binding for it, return the "combiner" function that determines the semantics of the entire form and further parses and processes it in possibly arbitrary ways. Else if we do not have a binding, return None to indicate that the form should not be handled according to the operator and that the operands should simply be recursively parsed.

impl<P: Debug, DA: Debug, OR: Debug, AR: Debug, CE: Debug> Debug for PairOperatorBindings<P, DA, OR, AR, CE> where
    P: Borrow<[(Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>)]>,
    DA: DatumAllocator, 

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

Formats the value using the given formatter.

impl<P, DA, OR, AR, CE> Default for PairOperatorBindings<P, DA, OR, AR, CE> where
    P: Default + Borrow<[(Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>)]>,
    DA: DatumAllocator, 

fn default() -> Self

Make a new instance of Self using the Default::default() of our pairs' type.