Trait lattices::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.

Object Safety

This trait is not object safe.

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>,

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>,

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

type AtomIter = Box<dyn Iterator<Item = <WithTop<Inner> 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,

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

type AtomIter = Box<dyn Iterator<Item = <UnionFind<Map> 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>,

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

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

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

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

type Atom = SetUnion<SingletonSet<Item>>

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