Trait PotentialWell

Source

pub trait PotentialWell {
    type Well<T>: KineticWell<Target = T>;

    // Required method
    fn new<T>(data: T) -> Self::Well<T>;
}

Expand description

Potential well, representing a generic container.

Useful for recursive data structures, since it avoids recursive types.

§Examples

Atomic linked list via PotentialWell:

use potential_well::{PotentialWell, PotentialAtomicOption};

struct Link<T, W: PotentialWell = Box<()>> {
    data: T,
    next: PotentialAtomicOption<Link<T, W>, W>
}
struct List<T, W: PotentialWell = Box<()>> {
    root: PotentialAtomicOption<Link<T, W>, W>,
}

let list: List<u32> = List {
    root: PotentialAtomicOption::some(Box::new(Link {
        data: 1,
        next: PotentialAtomicOption::some(Box::new(Link {
            data: 2,
            next: PotentialAtomicOption::some(Box::new(Link {
                data: 3,
                next: PotentialAtomicOption::none(),
            }))
        })),
    })),
};

// no Drop implementation needed!
drop(list);

Without PotentialWell, you immediately run into trouble:

use potential_well::{Well, AtomicOption};

// recursive type: Link<T, Box<Link<T, Box<Link<T, ...>>>>>
struct Link<T, W: Well<Target = Link<T, Self>>> {
    data: T,
    next: AtomicOption<W>,
}
struct List<T, W: Well<Target = Link<T, Self>>> {
    root: AtomicOption<W>,
}

let list: List<u32, Box<_>> = List {
    root: AtomicOption::some(Box::new(Link {
        data: 1,
        next: AtomicOption::some(Box::new(Link {
            data: 2,
            next: AtomicOption::some(Box::new(Link {
                data: 3,
                next: AtomicOption::none(),
            }))
        })),
    })),
};