Enum Concrete 

pub enum Concrete {
    Null,
    Bool(bool),
    Int(i64),
    Float(f64),
    String(Rc<NixString>),
    Path(Box<SmolStr>),
    List(Rc<NixList>),
    Attrs(Rc<NixAttrs>),
    Lambda(Rc<Closure>),
    Builtin(Box<BuiltinFn>),
}

A demanded Nix value. Guaranteed NOT a Thunk at the TYPE level.

Unlike Value (which has a Thunk variant), Concrete is a separate enum that DOES NOT HAVE a Thunk variant. The compiler rejects any attempt to construct a Concrete from a thunk — the variant simply doesn’t exist.

The ONLY way to obtain a Concrete is through Value::demand().

let val: Value = eval_expr(expr, env)?;  // might be Thunk
let c: Concrete = val.demand()?;          // NOW guaranteed concrete
let n: i64 = c.as_int()?;                // type-safe, thunk-free

Variants

Null

Bool(bool)

Int(i64)

Float(f64)

String(Rc<NixString>)

Path(Box<SmolStr>)

List(Rc<NixList>)

Attrs(Rc<NixAttrs>)

Lambda(Rc<Closure>)

Builtin(Box<BuiltinFn>)

Implementations

impl Concrete

pub fn into_value(self) -> Value

Convert back to a Value (for APIs that still take Value).

pub fn to_value(&self) -> Value

Borrow as a Value reference. Constructs a temporary Value. Prefer specific accessors (as_bool, as_int, etc.) when possible.

pub fn as_bool(&self) -> Result<bool, EvalError>

Extract bool — guaranteed no thunk.

pub fn as_int(&self) -> Result<i64, EvalError>

Extract int — guaranteed no thunk.

pub fn as_str(&self) -> Result<&str, EvalError>

Extract string ref — guaranteed no thunk.

pub fn as_nix_string(&self) -> Result<&NixString, EvalError>

Extract NixString ref — guaranteed no thunk.

pub fn as_list(&self) -> Result<&[Value], EvalError>

Extract list ref — guaranteed no thunk at this level. Note: list ELEMENTS may still be lazy (Value, not Concrete).

pub fn as_attrs(&self) -> Result<&NixAttrs, EvalError>

Extract attrs ref — guaranteed no thunk at this level. Note: attr VALUES may still be lazy (Value, not Concrete).

pub fn as_float(&self) -> Result<f64, EvalError>

Extract float — guaranteed no thunk.

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

Check the value type name.

pub fn as_string(&self) -> Result<&str, EvalError>

Alias for as_str() — API parity with Value::as_string().

pub fn to_attrs(&self) -> Result<NixAttrs, EvalError>

Extract owned NixAttrs — guaranteed no thunk at this level.

pub fn to_list(&self) -> Result<Vec<Value>, EvalError>

Extract owned list — guaranteed no thunk at this level.

pub fn coerce_to_path(&self, context: &str) -> Result<String, EvalError>

Extract a filesystem path from Path or String.

pub fn to_str(&self) -> Result<String, EvalError>

Extract owned string.

pub fn to_nix_string(&self) -> Result<NixString, EvalError>

Extract owned NixString (with context).

pub fn is_function(&self) -> bool

Check if value is a function (lambda or builtin).

Trait Implementations

impl Clone for Concrete

fn clone(&self) -> Concrete

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Concrete

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

Formats the value using the given formatter.

impl From<Concrete> for Value

fn from(c: Concrete) -> Value

Converts to this type from the input type.

impl PartialEq for Concrete

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

Equality operator ==.

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

Inequality operator !=.