Struct PacCell

pub struct PacCell<P, C>(/* private fields */);

A cell of a parent and a child, which is created by mutably borrowing the parent. While the parent is in the cell, it cannot be accessed in any way. Provides mutable access to the child.

This is useful in a rare case when you need to store and move both parent and their child together.

Examples

Basic usage:

struct Hello {
    world: i64,
}
let hello = Hello { world: 10 };

let mut pac = pac_cell::PacCell::new(hello, |h| &mut h.world);

let initial = pac.with_mut(|world| {
    let i = **world;
    **world = 12;
    i
});
assert_eq!(initial, 10);

let hello_again = pac.unwrap();
assert_eq!(hello_again.world, 12);

For a real-world-like example, see the crate tests.

Implementations

impl<'p, P: 'p, C> PacCell<P, C>

pub fn new<F>(parent: P, child_constructor: F) -> Self

where F: FnOnce(&'p mut P) -> C,

Creates Pac by moving the parent into a Box and then calling the child constructor.

pub fn try_new<F, E>(parent: P, child_constructor: F) -> Result<Self, E>

where F: FnOnce(&'p mut P) -> Result<C, E>,

Creates Pac by moving the parent into a Box and then calling the child constructor.

pub fn with_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut C) -> R,

Executes a function with a mutable reference to the child.

pub fn unwrap(self) -> P

Drop the child and return the parent.