Struct Trace 

pub struct Trace<T>(/* private fields */);

A stack-like structure to hold the module backtrace during evaluation.

A module trace is to the evaluator what Backtrace is to a program. In the trace, modules are stored in import-order. This means that the module where the error was caused is always the last one in the trace.

Implementations

impl<T> Trace<T>

pub const fn empty() -> Self

Create a new empty Trace.

pub fn len(&self) -> usize

Get the number of modules in the trace.

pub fn is_empty(&self) -> bool

Check whether the trace is empty.

pub fn current(&self) -> Option<&T>

Get a reference to the current module.

The current module is always the one that was pushed last. Returns None if the trace is empty.

pub fn push(&mut self, id: T)

Add a module to the trace.

Pushing a module makes that module the “deepest” level of the trace. See: Trace.

Example

let mut trace = Trace::empty();
trace.push("module 1");
trace.push("module 2");
trace.push("module 3");

assert_eq!(
    trace.iter().copied().collect::<Vec<_>>(),
    &[
        "module 1",
        "module 2",
        "module 3"
    ]
);

pub fn pop(&mut self) -> Option<T>

Remove the last module from the trace and return it.

Also see: push.

Example

let mut trace = Trace::empty();
trace.push("module 1");
trace.push("module 2");
trace.push("module 3");

assert_eq!(trace.pop(), Some("module 3"));
assert_eq!(trace.pop(), Some("module 2"));
assert_eq!(trace.pop(), Some("module 1"));
assert_eq!(trace.pop(), None);

pub fn iter(&self) -> Iter<'_, T>

Get an iterator over all modules in the trace.

The returned iterator traverses the trace from the deepest module to the shallowest. The returned iterator implements DoubleEndedIterator so you can use Iterator::rev.

Example

let mut trace = Trace::empty();
trace.push("module 1");
trace.push("module 2");
trace.push("module 3");

let mut iter = trace.iter();
assert_eq!(iter.next().copied(), Some("module 1"));
assert_eq!(iter.next().copied(), Some("module 2"));
assert_eq!(iter.next().copied(), Some("module 3"));
assert_eq!(iter.next().copied(), None);

Trait Implementations

impl<T: Clone> Clone for Trace<T>

fn clone(&self) -> Trace<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Trace<T>

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

Formats the value using the given formatter.

impl<T> Default for Trace<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Trace<T>> for Vec<T>

fn from(x: Trace<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Trace<T>

fn from(x: Vec<T>) -> Self

Converts to this type from the input type.

impl<'a, T> IntoIterator for &'a Trace<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.