Struct GhostToken 

pub struct GhostToken<'brand>(/* private fields */);

A lifetime based token, inspired by ghost_cell.

Correct usage, where cells are only unlocked by providing a mutable reference to the token they were constructed with, will compile.

GhostToken::with_token(|mut t1| {
    let c1 = TokenCell::new(1, &t1);
    GhostToken::with_token(|mut t2| {
        let c2 = TokenCell::new(1, &t2);
        println!("{}", *c2.borrow_mut(&mut t2));
        println!("{}", *c1.borrow_mut(&mut t1));
    })
    .unwrap();
    c1.borrow_mut(&mut t1);
})
.unwrap();

But using the wrong token with any given cell will fail at compile time.

 GhostToken::with_token(|mut t1| {
     let c1 = TokenCell::new(1, &t1);
     GhostToken::with_token(|mut t2| {
         println!("{}", *c1.borrow_mut(&mut t2));
     })
     .unwrap();
     c1.borrow_mut(&mut t1);
 })
 .unwrap();

GhostToken::with_token(|mut t1| {
    let c1 = TokenCell::new(1, &t1);
    GhostToken::with_token(|mut t2| {
        let c2 = TokenCell::new(1, &t2);
        println!("{}", *c2.borrow_mut(&mut t1));
        println!("{}", *c1.borrow_mut(&mut t1));
    })
    .unwrap();
    c1.borrow_mut(&mut t1);
})
.unwrap();

Trait Implementations

impl<'brand> TokenTrait for GhostToken<'brand>

fn with_token<R, F: for<'a> FnOnce(Self::Branded<'a>) -> R>( f: F, ) -> Result<R, Self::RunError>

use token_cell::{ghost::*, prelude::*};
GhostToken::with_token(|mut t1| {
    let c1 = TokenCell::new(1, &t1);
    GhostToken::with_token(|mut t2| {
        let c2 = TokenCell::new(1, &t2);
        println!("{}", *c2.borrow_mut(&mut t2));
        println!("{}", *c1.borrow_mut(&mut t1));
    })
    .unwrap();
    c1.borrow_mut(&mut t1);
})
.unwrap();

use token_cell::{ghost::*, prelude::*};
GhostToken::with_token(|mut t1| {
    let c1 = TokenCell::new(1, &t1);
    GhostToken::with_token(|mut t2| {
        let c2 = TokenCell::new(1, &t2);
        println!("{}", *c2.borrow_mut(&mut t2));
        println!("{}", *c1.borrow_mut(&mut t2));
    })
    .unwrap();
    c1.borrow_mut(&mut t1);
})
.unwrap();

type ConstructionError = ()

Constructing a token may fail.

type RunError = Infallible

TokenTrait::with_token may fail, typically if construction failed.

type Identifier = InvariantLifetime<'brand>

Lets a TokenCell keep track of the token.

type ComparisonError = Infallible

core::convert::Infallible unless TokenTrait::compare is fallible (ie. comparison is done at runtime).

type Branded<'a> = GhostToken<'a>

Rebrands the token, this is necessary for GhostToken to function properly

fn new() -> Result<Self, Self::ConstructionError>

Constructs a new Token.

fn identifier(&self) -> InvariantLifetime<'brand>

Returns the Token’s identifier, which cells may store to allow comparison.

fn compare( &self, _: &InvariantLifetime<'brand>, ) -> Result<(), Self::ComparisonError>

Allows the cell to compare its identifier to the Token.