Enum Value 

pub enum Value {
    Int(BigInt),
    Float(f64),
    Decimal(BigDecimal),
    Str(Rc<str>),
    Bytes(Rc<[u8]>),
    Bool(bool),
    None,
    List(Rc<RefCell<Vec<Value>>>),
    Dict(Rc<RefCell<OrderedMap>>),
    Object(Rc<RefCell<ObjectData>>),
    Function(Rc<FunctionData>),
    Class(Rc<FunctionData>),
    BoundMethod(Rc<BoundMethodData>),
    Error(Rc<ErrorData>),
    Socket(Rc<SocketData>),
    Pup(Rc<PupData>),
    Bowl(Rc<BowlData>),
}

A dynamically typed Doge value.

Variants

Int(BigInt)

An arbitrary-precision integer. Overflow never happens: an operation whose result outgrows the machine word just keeps more digits, so Int behaves as an unbounded integer to the user. The i64-sized fast path lives inside the operators, not the type.

Float(f64)

Decimal(BigDecimal)

An exact base-10 decimal, from dec(...). Unlike Float (binary, inexact), Decimal stores value as digits × 10^-scale, so dec("0.1") + dec("0.2") is exactly dec("0.3") — the type for money and any exact fractional maths. It mixes with Int (both exact) but not with Float (inexact): a Float/ Decimal arithmetic mix is a catchable TypeError.

Str(Rc<str>)

Bytes(Rc<[u8]>)

Raw binary data — an immutable, ref-counted byte string, the counterpart of Str for bytes that are not text. Where Str is char-based (indexing and len count characters), Bytes is byte-based: bytes[i] is an Int 0–255 and len counts bytes. Produced by bytes(...) and the binary fetch reads; decoded back to text with .decode().

Bool(bool)

None

List(Rc<RefCell<Vec<Value>>>)

Dict(Rc<RefCell<OrderedMap>>)

Object(Rc<RefCell<ObjectData>>)

Function(Rc<FunctionData>)

Class(Rc<FunctionData>)

A class name used as a value: a callable that constructs an instance. It carries the same FunctionData a function value does — its fn_id is a constructor arm in the call_function dispatcher — so the whole indirect call path works unchanged, but it keeps a distinct identity (prints <class Name>, type Class) rather than masquerading as a function.

BoundMethod(Rc<BoundMethodData>)

A method bound to its receiver: such f = a.speak captures both the object (or List/Dict) and the method name, so calling f(...) dispatches exactly as a.speak(...) would. Name-based, like a direct method call — it carries no fn_id, so both engines route it back through their method dispatch. Prints <method Class.name>, type Method, equal only to the same method bound to the very same receiver.

Error(Rc<ErrorData>)

Socket(Rc<SocketData>)

A network socket opened by the howl module: a TCP listener or an open connection, or a closed handle once howl.close has run. Sockets are opaque — they have no methods or fields, compare by identity, and close automatically when the last reference is dropped. Two socket values are the same socket only when they share this Rc.

Pup(Rc<PupData>)

A pup: a function running on its own OS thread, spawned by pack.zoom. Opaque like a socket — no methods or fields, identity comparison — and waited on with pack.fetch, which returns the function’s result (or re-raises the error it hit). A pup cannot be sent to another pup.

Bowl(Rc<BowlData>)

A bowl: an unbounded channel opened by pack.bowl, over which pups pass values (pack.drop/pack.sniff). Unlike every other value, a bowl is shared, not copied, when it crosses a pup boundary — both sides talk over the same channel. Opaque and compared by identity.

Implementations

impl Value

pub fn int(n: impl Into<BigInt>) -> Value

Build an Int value from anything that converts into a BigInt — an i64/u8/usize literal, or a computed BigInt. The single construction helper so call sites never spell BigInt::from themselves.

pub fn int_lit(digits: &str) -> Value

Build an Int from the decimal-digit string codegen emits for an integer literal too large to fit an i64 token. The compiler only ever emits a valid digit run here, so a parse failure is a compiler bug, not a user error.

pub fn decimal(d: BigDecimal) -> Value

Build a Decimal value from an exact BigDecimal.

pub fn str(s: impl AsRef<str>) -> Value

Build a Str value from anything string-like.

pub fn bytes(b: impl AsRef<[u8]>) -> Value

Build a Bytes value from any byte slice.

pub fn list(items: Vec<Value>) -> Value

Build a List value from a vector of elements.

pub fn dict(entries: OrderedMap) -> Value

Build a Dict value from an insertion-ordered map.

pub fn object(class_id: u32, class_name: &str) -> Value

Build a fresh instance of the class with class_id/class_name and no fields yet — the constructor fills them in with attr_set.

pub fn error(kind: ErrorKind, message: &str, file: Rc<str>, line: u32) -> Value

Build a caught Error value from a raised error’s category, message, and the file/line it was raised at (err.type / err.message / err.file / err.line). Built by crate::error::error_value at each catch site.

pub fn function(fn_id: u32, name: &str, captures: Vec<Cell>) -> Value

Build a first-class function value with fn_id, display name, and the captured captures cells (empty for a top-level function or a closure that captures nothing).

pub fn bound_method(receiver: Value, method: &str) -> Value

Build a bound-method value capturing receiver and the method name. The receiver is any value method dispatch accepts — a many instance, or a List/Dict for its collection methods.

pub fn socket(state: SocketState) -> Value

Build a socket value wrapping an initial [SocketState] — a fresh listener or connection from the howl module.

pub fn pup(handle: JoinHandle<Result<Packed, PackedError>>) -> Value

Build a running pup value around the join handle of its OS thread.

pub fn bowl(handle: BowlHandle) -> Value

Build a bowl value around a channel handle — a fresh channel from pack.bowl, or a shared handle rebuilt on the far side of a pup boundary.

pub fn class(fn_id: u32, name: &str) -> Value

Build a class value from the constructor arm fn_id and the class name. A class captures nothing — calling it always builds a fresh instance — so its captures are empty and two values for the same class compare equal.

pub fn dict_from_pairs(pairs: Vec<(Value, Value)>) -> DogeResult

Build a Dict from key/value pairs evaluated by a dict literal. Every key must be a Str; anything else is a catchable type error. Pairs are inserted in order, so when a key repeats the last entry wins.

pub fn truthy(&self) -> bool

Python-style truthiness: 0, 0.0, "", empty list/dict, none and false are falsy; everything else is truthy.

pub fn type_name(&self) -> &'static str

The user-facing type name, used in error messages.

pub fn describe(&self) -> String

The type name with the right English article, for error messages — "a Str", "an Int". Single source so every diagnostic reads the same.

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.