Enum Value 

pub enum Value {
    Int(BigInt),
    Sequence(Vec<Rc<Value>>),
    Function(Rc<Closure>),
    BuiltInFunction(BIF),
    AbstractSyntax(Ast),
    Struct(Assoc<Name, Value>),
    Enum(Name, Vec<Value>),
    Text(String),
    Cell(Rc<RefCell<Value>>),
    ParseContext(Box<ParseContext>),
}

Values in Unseemly.

Variants

Int(BigInt)

Sequence(Vec<Rc<Value>>)

Function(Rc<Closure>)

BuiltInFunction(BIF)

AbstractSyntax(Ast)

Struct(Assoc<Name, Value>)

Enum(Name, Vec<Value>)

Text(String)

Cell(Rc<RefCell<Value>>)

ParseContext(Box<ParseContext>)

Implementations

impl Value

pub fn prefab(self) -> Ast

Turns this Value into a “magic” Ast that evaluates to it. The Ast will have the universal type

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

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

fn ty_name() -> Name

A name for that type, so that recursive types are okay. Ignore the type parameters of Self; invoke like Self::<Irr,Irr>::ty_name(). e.g. WithInteger

fn reify(&self) -> Value

The Unseemly value that corresponds to a value.

fn reflect(v: &Value) -> Self

Get a value from an Unseemly value

fn ty() -> Ast

The Unseemly type that corresponds to to the Reifiable type. This leaves abstract the type parameters of Self; invoke like Self::<Irr,Irr>::ty(). e.g. ∀ A. Pair<A int> TODO: rename to generic_ty

fn ty_invocation() -> Ast

How to refer to this type, given an environment in which ty_name() is defined to be ty(). Parameters will be concrete. e.g. WithInteger<Float> (Types using this type will use this, rather than ty) Don’t override this.

fn concrete_arguments() -> Option<Vec<Ast>>

impl WalkElt for Value

fn from_ast(a: &Ast) -> Value

fn to_ast(&self) -> Ast

impl StructuralPartialEq for Value