Enum Val

pub enum Val {
    Constr(Name, Vec<Val>),
    Tuple(Vec<Val>),
    Vec(Vec<Val>),
    Struct(Name, Vec<(Name, Val)>),
    Art(Loc, ArtContent),
    Name(Name),
    Const(Const),
    ValTODO,
}

Reflected value; Gives a syntax for inductive data type constructors (Constr), named articulations (Art) and primitive data (Data). All values in the engine (including the values of nodes, and the values stored on edges) are represented with this reflected Val type. Primarily, this distinction between actual Rust values and this type is what makes the DCG engine “reflected” by the definitions in this module, and not identical to them.

Variants

Constr(Name, Vec<Val>)

Constructor, with a sequence of value parameters.

Tuple(Vec<Val>)

A tuple of values (like a constructor, but without a constructor name). Can be seen as a special case of Constr.

Vec(Vec<Val>)

A list of values (like a tuple, but parsed and printed differently). Can be seen as a special case of Constr.

Struct(Name, Vec<(Name, Val)>)

Constructor with a sequence of fields (name-value pairs) as parameters.

Art(Loc, ArtContent)

Named articulation, and its content (an Art is either a named value, or a named computation).

Name(Name)

First-class Name value.

Const(Const)

Primitive, immutable data.

ValTODO

Temporary; for marking places in code where we should produce a value, but don’t yet have a good way to do so.

Trait Implementations

impl Clone for Val

fn clone(&self) -> Val

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Val

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

Formats the value using the given formatter.

impl Hash for Val

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Val

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

impl StructuralPartialEq for Val