Enum fungi_lang::dynamics::RtVal

pub enum RtVal {
    Unit,
    Pair(RtValRec, RtValRec),
    Inj1(RtValRec),
    Inj2(RtValRec),
    Roll(RtValRec),
    NameFn(NameTm),
    Nat(usize),
    Str(String),
    Bool(bool),
    ThunkAnon(EnvRec, Exp),
    Name(Name),
    Ref(Ref),
    Thunk(Thk),
    Pack(RtValRec),
    HostObj(HostObj),
}

Run-time values. Compare to ast::Val.

Same as Val, except that these values are (1) closed and (2) may contain run time-only structures, from the Adapton entine:

• there are no variables (“closed”) and

• unlike values written by user in their program, run-time values may contain run-time structures, such as actual thunks and references, a la Arts from Adapton library.

Variants

Unit

Unit value

Pair(RtValRec, RtValRec)

Pair of run-time values

Inj1(RtValRec)

First injection of run-time value

Inj2(RtValRec)

Second injection of run-time value

Roll(RtValRec)

Rolled run-time value (with a recursive type)

NameFn(NameTm)

Dynamic name term

Nat(usize)

Natural number

Str(String)

String

Bool(bool)

Boolean

ThunkAnon(EnvRec, Exp)

Special-case thunk values: For implementing fix with environment-passing style

Name(Name)

AST Names; we convert to Adapton engine names when we use the engine API

Ref(Ref)

Refs from Adapton engine; they each contain a run-time value

Thunk(Thk)

Thunks from Adapton engine; they each evaluate to a terminal expression

Pack(RtValRec)

Existential packings; at run-time, we forget the choice of indices

HostObj(HostObj)

“Host objects”: native Rust objects

Trait Implementations

impl Clone for RtVal

fn clone(&self) -> RtVal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RtVal

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

Formats the value using the given formatter.

impl Display for RtVal

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

Formats the value using the given formatter.

impl Hash for RtVal

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<RtVal> for RtVal

fn eq(&self, other: &RtVal) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RtVal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RtVal

impl StructuralEq for RtVal

impl StructuralPartialEq for RtVal