Struct tvix_eval::Builtin

pub struct Builtin(Box<BuiltinRepr>);

Represents a single built-in function which directly executes Rust code that operates on a Nix value.

Builtins are the only functions in Nix that have varying arities (for example, hasAttr has an arity of 2, but isAttrs an arity of 1). To facilitate this generically, builtins expect to be called with a vector of Nix values corresponding to their arguments in order.

Partially applied builtins act similar to closures in that they “capture” the partially applied arguments, and are treated specially when printing their representation etc.

Tuple Fields

0: Box<BuiltinRepr>

Implementations

impl Builtin

pub fn new<F: BuiltinGen + 'static>( name: &'static str, documentation: Option<&'static str>, arg_count: usize, func: F, ) -> Self

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

pub fn documentation(&self) -> Option<&'static str>

pub fn apply_arg(&mut self, arg: Value)

Apply an additional argument to the builtin. After this, Builtin::call must be called, otherwise it may leave the builtin in an incorrect state.

pub fn call(self) -> BuiltinResult

Attempt to call a builtin, which will produce a generator if it is fully applied or return the builtin if it is partially applied.

Trait Implementations

impl Clone for Builtin

fn clone(&self) -> Builtin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Builtin

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

Formats the value using the given formatter.

impl Display for Builtin

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

Formats the value using the given formatter.

impl From<BuiltinRepr> for Builtin

fn from(value: BuiltinRepr) -> Self

Converts to this type from the input type.

impl PartialEq for Builtin

Builtins are uniquely identified by their name

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