#lifetime #self-referential #borrowing #ownership #achieve


Crate to open a scope and then freeze it in time for future access

7 unstable releases (3 breaking)

new 0.4.0 Apr 19, 2024
0.3.3 Jan 6, 2024
0.3.1 Nov 26, 2023
0.2.0 Dec 27, 2022
0.1.0 Nov 1, 2022

#375 in Rust patterns

Download history 11/week @ 2024-01-01 16/week @ 2024-02-12 18/week @ 2024-02-19 11/week @ 2024-02-26 14/week @ 2024-03-11 36/week @ 2024-04-01 108/week @ 2024-04-15

144 downloads per month


488 lines

Open a scope and then freeze it in time for future access.

License Crates.io Docs dependency status Build

This crate allows constructing structs that contain references and keeping them alive alongside the data they reference, without a lifetime.

This is especially useful for zero-copy parsers that construct elaborate (and possibly costly) representations that borrow the source data.

This crate achieves that by leveraging async functions. At their core, async functions are self-referential structs. this crate simply provides a way to ex-filtrate references outside of the async function, in a controlled manner.

Using this crate

After you identified the data and its borrowed representation that you'd like to access without a lifetime, using this crate will typically encompass a few steps:

// Given the following types:
struct MyData(Vec<u8>);
struct MyParsedData<'a>(&'a mut MyData, /* ... */);

// 1. Define a helper type that will express where the lifetimes of the borrowed representation live.
struct MyParsedDataFamily; // empty type, no lifetime.
impl<'a> nolife::Family<'a> for MyParsedDataFamily {
    type Family = MyParsedData<'a>; // Indicates how the type is tied to the trait's lifetime.
    // you generally want to replace all lifetimes in the struct with the one of the trait.

// 2. Define a function that setups the data and its borrowed representation:
fn my_scope(
    data_source: Vec<u8>, // 👈 all parameters that allow to build a `MyData`
) -> impl nolife::TopScope<Family = MyParsedDataFamily> // 👈 use the helper type we declared
        let mut data = MyData(data_source);
        let mut parsed_data = MyParsedData(&mut data); // imagine that this step is costly...
        freeze_forever!(&mut parsed_data) // gives access to the parsed data to the outside.
                       /* 👆 reference to the borrowed data */

// 3. Open a `BoxScope` using the previously written async function:
let mut scope = nolife::BoxScope::<MyParsedDataFamily>::new_dyn(my_scope(vec![0, 1, 2]));

// 4. Store the `BoxScope` anywhere you want
struct ContainsScope {
    scope: nolife::BoxScope<MyParsedDataFamily>,
    /* other data */

// 5. Lastly, enter the scope to retrieve access to the referenced value.
scope.enter(|parsed_data| { /* do what you need with the parsed data */ });

Kinds of scopes

This crate only provide a single kind of scope at the moment

Scope Allocations Moveable after opening Thread-safe
BoxScope 1 (size of the contained Future + 1 pointer to the reference type) Yes No

An RcScope or MutexScope could be future extensions


Licensed under either of Apache License, Version 2.0 or MIT license at your option.

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


yoke serves a similar use case as this crate, albeit it is expressed in terms of a self-referential struct rather than as an async scope, which is less natural if the intent is to borrow some data.

No runtime deps