Enum kul_core::Datum

pub enum Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>,  {
    Text(TextType),
    Combination {
        operator: DatumRef,
        operands: DatumRef,
    },
    EmptyNest,
    List {
        elem: DatumRef,
        next: DatumRef,
    },
    EmptyList,
    Extra(ExtraType),
}

The abstract syntax tree (AST) type returned by parsing. It is extensible by the ExtraType parameter, and it is parameterized over the DatumRef type used to refer to the other Datums in an AST. It can also be used for DAGs.

Variants

Text(TextType)

A logically unbroken span of text. (Only nest forms break text logically, but escape characters break the representation into chunks.)

Combination

A nest form that is not empty and so has a non-empty "operator"/"head" sub-form and has a possibly-empty "operands" sub-form(s).

Fields of Combination

operator: DatumRef

The operator form, as any Datum variant.

operands: DatumRef

The operands form, as a List or EmptyList or a Text variant.

EmptyNest

An empty nest form

List

A list of other Datums. Used to represent parsed operands.

Fields of List

elem: DatumRef

An element of the list, as any Datum variant.

next: DatumRef

The rest of the list, as a List or EmptyList variant.

EmptyList

An empty list

Extra(ExtraType)

Extensibility that custom macros/combiners may utilize to add additional variants

Trait Implementations

impl<TextType: Debug, ExtraType: Debug, DatumRef: Debug> Debug for Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>, 

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

Formats the value using the given formatter.

impl<TT1, TT2, ET1, ET2, DR1, DR2> PartialEq<Datum<TT2, ET2, DR2>> for Datum<TT1, ET1, DR1> where
    DR1: DerefTryMut<Target = Datum<TT1, ET1, DR1>>,
    DR2: DerefTryMut<Target = Datum<TT2, ET2, DR2>>,
    TT1: PartialEq<TT2>,
    ET1: PartialEq<ET2>, 

This allows different concrete Datum types to be compared with each other for equality if their "extra" types can be. This also avoids stack overflows for long lists and deep nests (but can still overflow on other deep tree shapes, but those are rare).

fn eq(&self, other: &Datum<TT2, ET2, DR2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<TextType: Eq, ExtraType: Eq, DatumRef: Eq> Eq for Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>, 

impl<TextType: Hash, ExtraType: Hash, DatumRef: Hash> Hash for Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>, 

fn hash<__HTextTypeExtraTypeDatumRef: Hasher>(
    &self,
    state: &mut __HTextTypeExtraTypeDatumRef
)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<TextType: Copy, ExtraType: Copy, DatumRef: Copy> Copy for Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>, 

impl<TextType: Clone, ExtraType: Clone, DatumRef: Clone> Clone for Datum<TextType, ExtraType, DatumRef> where
    DatumRef: DerefTryMut<Target = Datum<TextType, ExtraType, DatumRef>>, 

fn clone(&self) -> Datum<TextType, ExtraType, DatumRef>

Returns a copy of the value.

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

Performs copy-assignment from source.