temp-stack 1.0.1

A data structure for contexts or similar stack structures that are allocated on the call stack, using the temp-inst crate for lifetime erasure.
Documentation

temp-stack crate

TempStack is a linked list data structure based on the temp-inst crate. The intended use case is that list items are allocated on the call stack; then the list also represents a "stack" with "frames". Via temp-inst, each frame can contain references to data that is available at the point where it is constructed, without having to add lifetime parameters.

Example

A parser or compiler or interpreter can use a TempStack reference as a context that is passed to individual functions, to determine which variables are in scope. For example, a context with just variable names might be defined as

type Ctx = TempStack<(), TempRef<str>>;

Due to the use of TempRef from the temp-inst crate, no lifetime parameters are required to access local string slices.

A function can construct construct a new context with an added variable, and pass it to another function:

fn parse_expr<'a>(s: &'a str, ctx: &Ctx) -> (Expr, &'a str) {
    // ...
    if is_lambda {
        let (s, name) = parse_name(s);
        let body_ctx = ctx.new_frame(name);
        return parse_expr(s, &body_ctx);
    }
    // ...
}

We can easily iterate over a context to find a given variable:

fn parse_expr<'a>(s: &'a str, ctx: &Ctx) -> (Expr, &'a str) {
    // ...
    if is_var {
        let (s, name) = parse_name(s);
        // Determine the De Bruijn index of the nearest `name` in context.
        let Some(idx) = ctx.iter().position(|v| v == name) else ...
        // ...
    }
}

See the documentation for the complete example.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.