# Passable 🛳

Pass a pointer around. Kinda like `Rc`, but there can only be one accessor at a time, making mutation possible. When a `Pass` holding the reference is dropped, it gives the reference back to its predecessor.

```rust
use passable::Pass;

let mut one = Pass::new("hello");

{
    let mut two = one.pass().unwrap();

    // now two has the reference, and not one.
    assert_eq!(two.deref(), Some(&"hello"));
    assert_eq!(one.deref(), None);

    *two.deref_mut().unwrap() = "goodbye";
}

// two is dropped here, giving the reference back to one.

assert_eq!(one.deref(), Some(&"goodbye"));
```

You can also drop a reference in the middle of the chain.

```rust
use passable::Pass;

let mut one = Pass::new(true);

let mut two = one.pass().unwrap();
*two.deref_mut().unwrap() = false;

let mut three = two.pass().unwrap();

std::mem::drop(two);

assert_eq!(three.deref(), Some(&false));

*three.deref_mut().unwrap() = true;
std::mem::drop(three);

assert_eq!(one.deref(), Some(&true));
```

## Notes 
* `Pass` implements `Default`, but it does not implement any of the other std library traits that rely on having a reference to the internal value, like `Clone`, `Debug`, and `Display`. If you have a suggestion for how these should be implemented when the `Pass` does not have a reference to the internal value, please submit an issue!
* `Pass` is implemented as a linked list, with each node holding an `Option<NonNull<T>>` to the internal value. Each `Pass` object on the stack has a size of 8 bytes, and each node in the list has a size of 24 bytes.