Trait Atomize 

pub trait Atomize: Merge<Self::Atom> {
    type Atom: 'static + IsBot;
    type AtomIter: 'static + Iterator<Item = Self::Atom>;

    // Required method
    fn atomize(self) -> Self::AtomIter;
}

Trait to atomize a lattice into individual elements. For example, a set_union::SetUnion will be broken up into individual singleton elements.

Formally, breaks up Self into an set of lattice points forming a (strong) antichain. “Strong” in the sense that any pair of lattice points in the antichain should have a greatest lower bound (GLB or “meet”) of bottom.

Required Associated Types

type Atom: 'static + IsBot

The type of atoms for this lattice.

type AtomIter: 'static + Iterator<Item = Self::Atom>

The iter type iterating the antichain atoms.

Required Methods

fn atomize(self) -> Self::AtomIter

Atomize self: convert into an iter of atoms.

The returned iterator should be empty if and only if self.is_bot() is true. All atoms in the returned iterator should have self.is_bot() be false.

Returned values must merge to reform a value equal to the original self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Atomize for ()

type Atom = ()

type AtomIter = Empty<()>

fn atomize(self) -> Self::AtomIter

Implementors

impl<Inner> Atomize for WithBot<Inner>

where Inner: 'static + Atomize + LatticeFrom<<Inner as Atomize>::Atom>,

Available on crate feature alloc only.

type Atom = WithBot<<Inner as Atomize>::Atom>

type AtomIter = Box<dyn Iterator<Item = <WithBot<Inner> as Atomize>::Atom>>

impl<Inner> Atomize for WithTop<Inner>

where Inner: Atomize + LatticeFrom<<Inner as Atomize>::Atom>,

Available on crate feature alloc only.

type Atom = WithTop<<Inner as Atomize>::Atom>

type AtomIter = Box<dyn Iterator<Item = <WithTop<Inner> as Atomize>::Atom>>

impl<Map, K, Val> Atomize for MapUnion<Map>

where Map: 'static + IntoIterator<Item = (K, Val)> + Keyed<Key = K, Item = Val> + Extend<(K, Val)> + for<'a> GetMut<&'a K, Item = Val>, K: 'static + Clone, Val: 'static + Atomize + LatticeFrom<<Val as Atomize>::Atom>,

Available on crate feature alloc only.

type Atom = MapUnion<SingletonMap<K, <Val as Atomize>::Atom>>

type AtomIter = Box<dyn Iterator<Item = <MapUnion<Map> as Atomize>::Atom>>

impl<Map, K> Atomize for UnionFind<Map>

where Map: 'static + MapMut<K, Cell<K>, Key = K, Item = Cell<K>> + IntoIterator<Item = (K, Cell<K>)>, K: 'static + Copy + Eq,

Available on crate feature std only.

type Atom = UnionFind<SingletonMap<K, Cell<K>>>

type AtomIter = Box<dyn Iterator<Item = <UnionFind<Map> as Atomize>::Atom>>

impl<Set, Item> Atomize for SetUnion<Set>

where Set: Len + IntoIterator<Item = Item> + Extend<Item>, Set::IntoIter: 'static, Item: 'static,

Available on crate feature alloc only.

type Atom = SetUnion<SingletonSet<Item>>

type AtomIter = Box<dyn Iterator<Item = <SetUnion<Set> as Atomize>::Atom>>