Enum Value 

pub enum Value {
    Int(i64),
    Float(OrdF64),
    Bool(bool),
    String(BockString),
    Char(char),
    Void,
    List(Vec<Value>),
    Map(BTreeMap<Value, Value>),
    Set(BTreeSet<Value>),
    Tuple(Vec<Value>),
    Record(RecordValue),
    Enum(EnumValue),
    Function(FnValue),
    Optional(Option<Box<Value>>),
    Result(Result<Box<Value>, Box<Value>>),
    Range {
        start: i64,
        end: i64,
        inclusive: bool,
        step: i64,
    },
    Iterator(IteratorValue),
    StringBuilder(Arc<Mutex<String>>),
    Future(FutureHandle),
    Duration(i64),
    Instant(Instant),
    Channel(Arc<ChannelHandle>),
}

A runtime value in the Bock interpreter.

Every Bock type maps to a variant. Collections requiring total order (Map, Set) work because Value implements Ord — with the single exception that ordering Function values is a runtime panic.

Variants

Int(i64)

64-bit signed integer.

Float(OrdF64)

64-bit float with total ordering.

Bool(bool)

Boolean.

String(BockString)

Unicode string.

Char(char)

Unicode scalar character.

Void

Unit / void.

List(Vec<Value>)

Homogeneous list.

Map(BTreeMap<Value, Value>)

Ordered key-value map (keys must not be functions).

Set(BTreeSet<Value>)

Ordered set (elements must not be functions).

Tuple(Vec<Value>)

Fixed-size heterogeneous tuple.

Record(RecordValue)

Record (struct) value.

Enum(EnumValue)

Enum (sum type) value.

Function(FnValue)

Function value — equal only to itself; ordering is a runtime error.

Optional(Option<Box<Value>>)

Optional value (Some(v) or None).

Result(Result<Box<Value>, Box<Value>>)

Result value (Ok(v) or Err(e)).

Range

An integer range with a step (produced by lo..hi / lo..=hi / .step()).

Fields

start: i64

end: i64

inclusive: bool

step: i64

Iterator(IteratorValue)

A lazy iterator value.

StringBuilder(Arc<Mutex<String>>)

Mutable string builder for efficient concatenation.

Future(FutureHandle)

A pending async computation.

Created when an async fn is called; resolved by await. The JoinHandle lives behind an Arc<Mutex<Option<...>>> so the Future value can be cloned (handles share the same task) and the handle can be take()-n on first await.

Duration(i64)

A time duration as signed nanoseconds (±292 year range).

Instant(Instant)

A monotonic point in time (per-process).

Channel(Arc<ChannelHandle>)

An unbounded async channel. Channel.new() returns a tuple of two clones of the same handle; send and recv both operate on the shared mpsc queue.

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

Formats the value using the given formatter.

impl Hash for Value

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 Ord for Value

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Value

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Value