Struct lamcal::inspect::Limit

pub struct Limit { /* fields omitted */ }

Limits the number of steps a reduction or evaluation function performs until processing is stopped.

This inspection counts each call to the Inspect::inspect function. If the number of calls counted so far is less than the limit for which the Limit has been constructed it returns Stop::No to continue processing. If the limit has been reached it returns Stop::Yes to instruct the evaluation or reduction function to stop processing.

A limit of 0 means that not reduction will be performed at all.

Examples

let mut term = app(
    lam("a", app(var("a"), var("a"))),
    lam("a", app(var("a"), var("a"))),
);

term.reduce_inspected::<NormalOrder<Enumerate>, _>(&mut Limit::new(5));

Methods

impl Limit

pub fn new(limit: u32) -> Self

Constructs a new Limit inspection with the given number of steps as the limit of reduction or evaluation steps.

pub fn limit(&self) -> u32

The limit for the number steps.

pub fn count(&self) -> u32

The number of steps counted so far.

Trait Implementations

impl Debug for Limit

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

Formats the value using the given formatter.

impl Clone for Limit

fn clone(&self) -> Limit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for Limit

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Default for Limit

fn default() -> Self

Returns the "default value" for a type.

impl Inspect for Limit

fn inspect(&mut self, _term: &Term) -> Stop

Inspects the term before the next step during processing and returns whether to continue processing or to stop it.