Struct NoUnwindVirtualMachine 

pub struct NoUnwindVirtualMachine<'ctxt, R: ImportResolver, C: Cache>(/* private fields */);

An wrapper around VirtualMachine which doesn’t unwind the VM stack upon destruction.

Unwinding ensures all thunks are properly cleaned from their previous state if the VM abort, which makes it possible to run subsequent evaluations (whether in the same or another VM instance). Since VM are light instances that are built on the spot, the default behavior is to unwind upon dropping, to avoid bad surprises (and unwinding is virtually free if the evaluation succeeds, since the stack is then empty).

However, it could happen that in some workflows, one wishes to avoid the cost of unwinding. In that case, use this wrapper instead of VirtualMachine.

Implementations

impl<'ctxt, R: ImportResolver, C: Cache> NoUnwindVirtualMachine<'ctxt, R, C>

pub fn new(vm: VirtualMachine<'ctxt, R, C>) -> Self

Methods from Deref<Target = VirtualMachine<'ctxt, R, C>>

pub fn merge( &mut self, v1: NickelValue, env1: Environment, v2: NickelValue, env2: Environment, pos_op: PosIdx, mode: MergeMode, ) -> Result<Closure, ErrorKind>

Compute the merge of two evaluated operands. Support both standard merging and record contract application.

Mode

In MergeMode::Contract mode, t1 must be the value and t2 must be the contract. It is important as merge is not commutative in this mode.

pub fn continue_op(&mut self, closure: Closure) -> Result<Closure, ErrorKind>

Proceeds to the next step of the evaluation of a primitive operation.

Depending on the content of the stack, it either starts the evaluation of the next argument or finally proceed with the operation if all arguments are evaluated.

pub fn warn(&mut self, warning: Warning)

pub fn reset(&mut self)

Reset the state of the machine (stacks, eval mode and state of cached elements) to prepare for another evaluation round.

pub fn import_resolver(&self) -> &R

pub fn import_resolver_mut(&mut self) -> &mut R

pub fn eval(&mut self, value: NickelValue) -> Result<NickelValue, EvalError>

Evaluate a Nickel expression. Wrapper around VirtualMachine::eval_closure that starts from an empty local environment and drops the final environment.

pub fn eval_full( &mut self, value: NickelValue, ) -> Result<NickelValue, EvalError>

Fully evaluate a Nickel term: the result is not a WHNF but to a value with all variables substituted.

pub fn eval_full_closure( &mut self, closure: Closure, ) -> Result<Closure, EvalError>

Same as Self::eval_full, but takes a closure as an argument instead of a term.

pub fn eval_full_for_export( &mut self, value: NickelValue, ) -> Result<NickelValue, EvalError>

Like Self::eval_full, but skips evaluating record fields marked not_exported.

pub fn eval_full_for_export_closure( &mut self, closure: Closure, ) -> Result<NickelValue, EvalError>

Same as Self::eval_full_for_export, but takes a closure as an argument instead of a term.

pub fn eval_deep( &mut self, value: NickelValue, ) -> Result<NickelValue, EvalError>

Fully evaluates a Nickel term like eval_full, but does not substitute all variables.

pub fn eval_deep_closure( &mut self, closure: Closure, ) -> Result<NickelValue, EvalError>

Same as Self::eval_deep, but take a closure as an argument instead of a term.

pub fn extract_field_closure( &mut self, closure: Closure, path: &FieldPath, ) -> Result<(Field, Environment), EvalError>

Take a term and a field path, and evaluate until the corresponding field can be extracted. Return the resulting field in its final environment.

Note that this method doesn’t evaluate the content of the field itself. Calling it with an empty path simply returns the original expression unevaluated in an empty environment. If you need to evaluate the value later, don’t forget to apply pending contracts stored in the field.

For example, extracting foo.bar.baz on a term exp will evaluate exp to a record and try to extract the field foo. If anything goes wrong (the result isn’t a record or the field bar doesn’t exist), a proper error is raised. Otherwise, Self::extract_field_closure applies the same recipe recursively and evaluate the content of the foo field extracted from exp to a record, tries to extract bar, and so on.

pub fn extract_field_value_closure( &mut self, closure: Closure, path: &FieldPath, ) -> Result<Closure, EvalError>

Same as Self::extract_field_closure, but also requires that the field value is defined and returns the value directly.

This method also applies potential pending contracts to the value.

In theory, extracting the value could be done manually after calling to Self::extract_field_closure, instead of needing a separate method.

However, once Self::extract_field_closure returns, most contextual information required to raise a proper error if the field is missing (e.g. positions) has been lost. So, if the returned field’s value is None, we would have a hard time reporting a good error message. On the other hand, Self::extract_field_value_closure raises the error earlier, when the context is still available.

pub fn query( &mut self, v: NickelValue, path: &FieldPath, ) -> Result<Field, EvalError>

pub fn query_closure( &mut self, closure: Closure, path: &FieldPath, ) -> Result<Field, EvalError>

Same as VirtualMachine::query, but starts from a closure instead of a term in an empty environment.

pub fn eval_closure(&mut self, closure: Closure) -> Result<Closure, EvalError>

The main loop of evaluation.

Implement the evaluation loop of the core language. The specific implementations of primitive operations is delegated to the modules operation and merge.

Arguments

• clos: the closure to evaluate
• initial_env: the initial environment containing the stdlib items. Accessible from anywhere in the program.

Return

Either:

• an evaluation error
• the evaluated term with its final environment

pub fn eval_permissive( &mut self, value: NickelValue, recursion_limit: usize, ) -> Vec<EvalError>

Evaluate a term, but attempt to continue on errors.

This differs from VirtualMachine::eval_full in three ways:

• We try to accumulate errors instead of bailing out. When recursing into record fields and array elements, we keep evaluating subsequent elements even if one fails.
• We only return the accumulated errors; we don’t return the eval’ed term.
• We support a recursion limit, to limit the number of times we recurse into arrays or records.

Trait Implementations

impl<'ctxt, R: ImportResolver, C: Cache> Deref for NoUnwindVirtualMachine<'ctxt, R, C>

type Target = VirtualMachine<'ctxt, R, C>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'ctxt, R: ImportResolver, C: Cache> DerefMut for NoUnwindVirtualMachine<'ctxt, R, C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.