Struct kul::parser::HashMapOperatorBindings

pub struct HashMapOperatorBindings<DA, OR, AR, CE, S = RandomState> where
    DA: DatumAllocator,
    DA::TT: Hash + Eq,
    DA::ET: Hash + Eq,
    DA::DR: Hash + Eq,
    S: BuildHasher,  {
    pub hashmap: HashMap<Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>, S>,
    // some fields omitted
}

An OperatorBindings that associates generic Datums with generic Combiners, using a HashMap.

The Datum keys 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 populating the hashmap field with the desired bindings, and it may be dynamically mutated inbetween parser invocations, if desired.

Fields

hashmap: HashMap<Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>, S>

The HashMap of operators bound to macros. You must populate and manage this yourself.

Methods

impl<DA, OR, AR, CE, S> HashMapOperatorBindings<DA, OR, AR, CE, S> where
    DA: DatumAllocator,
    DA::TT: Hash + Eq,
    DA::ET: Hash + Eq,
    DA::DR: Hash + Eq,
    S: BuildHasher, 

pub fn new(
    hashmap: HashMap<Datum<DA::TT, DA::ET, DA::DR>, Combiner<OR, AR>, S>
) -> Self

Given a HashMap of our type, make a new instance of Self that uses it for its hashmap field.

This enables using a premade HashMap, possibly with a certain capacity and/or with a different hashing algorithm (as supported by HashMap).

Trait Implementations

impl<DA, OR, AR, CE, S> Default for HashMapOperatorBindings<DA, OR, AR, CE, S> where
    DA: DatumAllocator,
    DA::TT: Hash + Eq,
    DA::ET: Hash + Eq,
    DA::DR: Hash + Eq,
    S: BuildHasher + Default, 

fn default() -> Self

Make a new instance of Self using the HashMap::default() of our type.

impl<DA: Debug, OR: Debug, AR: Debug, CE: Debug, S: Debug> Debug for HashMapOperatorBindings<DA, OR, AR, CE, S> where
    DA: DatumAllocator,
    DA::TT: Hash + Eq,
    DA::ET: Hash + Eq,
    DA::DR: Hash + Eq,
    S: BuildHasher,
    DA::TT: Debug,
    DA::ET: Debug,
    DA::DR: Debug, 

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

Formats the value using the given formatter.

impl<DA, OR, AR, CE, S> OperatorBindings<DA> for HashMapOperatorBindings<DA, OR, AR, CE, S> where
    DA: DatumAllocator,
    DA::TT: Hash + Eq,
    DA::ET: Hash + Eq,
    DA::DR: Hash + Eq,
    S: BuildHasher,
    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.