Trait Lattice 

pub trait Lattice: Sized {
    type Item: Clone + Eq + HashedTypeDef;

    // Required methods
    fn rand_lattice<R: Rng>(rng: &mut R) -> Self;
    fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>;
    fn ref_lattice_hash(&self) -> &u128slx;
    fn contains(&self, element: &Self::Item) -> bool;
    fn ref_bottom(&self) -> &SafeElement<Self::Item>;
    fn ref_top(&self) -> &SafeElement<Self::Item>;
    unsafe fn unsafe_meet(
        &self,
        element_left: &Self::Item,
        element_right: &Self::Item,
    ) -> Self::Item;
    unsafe fn unsafe_join(
        &self,
        element_left: &Self::Item,
        element_right: &Self::Item,
    ) -> Self::Item;
    fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>;
    fn to_string(
        &self,
        element: &SafeElement<Self::Item>,
    ) -> Result<String, String>;

    // Provided methods
    fn lattice_hash(&self) -> u128slx { ... }
    fn bottom(&self) -> SafeElement<Self::Item> { ... }
    fn top(&self) -> SafeElement<Self::Item> { ... }
    fn is_bottom(
        &self,
        safe_element: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn is_top(
        &self,
        safe_element: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    unsafe fn unsafe_is_bottom(&self, element: &Self::Item) -> bool { ... }
    unsafe fn unsafe_is_top(&self, element: &Self::Item) -> bool { ... }
    fn meet(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<SafeElement<Self::Item>, String> { ... }
    fn meet_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>
       where I: IntoIterator<Item = &'a SafeElement<Self::Item>>,
             Self: 'a { ... }
    fn join(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<SafeElement<Self::Item>, String> { ... }
    fn join_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>
       where I: IntoIterator<Item = &'a SafeElement<Self::Item>>,
             Self: 'a { ... }
    fn check_safe<T>(
        &self,
        element: T,
    ) -> Result<SafeElement<Self::Item>, String>
       where T: Into<Self::Item> { ... }
    fn rand_elements<R: Rng, I>(
        &self,
        len: usize,
        rng: &mut R,
    ) -> I::Type<SafeElement<Self::Item>>
       where I: CollectionFamily1 { ... }
    fn assignment(&self) -> AssignmentBuilder<Self::Item>
       where Self::Item: Eq + Ord + Hash { ... }
    fn assignment_with_capacity(
        &self,
        capacity: usize,
    ) -> AssignmentBuilder<Self::Item>
       where Self::Item: Eq + Ord + Hash { ... }
    fn prunable(
        &self,
        length_mid: u32,
        length_max: u32,
    ) -> AssignmentBuilder<Self::Item>
       where Self::Item: Eq + Ord + Hash { ... }
    fn prunable_with_capacity(
        &self,
        length_mid: u32,
        length_max: u32,
        capacity: usize,
    ) -> AssignmentBuilder<Self::Item>
       where Self::Item: Eq + Ord + Hash { ... }
    unsafe fn unsafe_cover(&self, left: &Self::Item, right: &Self::Item) -> bool { ... }
    unsafe fn unsafe_disjoint(
        &self,
        left: &Self::Item,
        right: &Self::Item,
    ) -> bool { ... }
    unsafe fn unsafe_implies_join(
        &self,
        left: &Self::Item,
        right: &Self::Item,
    ) -> bool { ... }
    unsafe fn unsafe_implied_join(
        &self,
        left: &Self::Item,
        right: &Self::Item,
    ) -> bool { ... }
    unsafe fn unsafe_implies_meet(
        &self,
        left: &Self::Item,
        right: &Self::Item,
    ) -> bool { ... }
    unsafe fn unsafe_implied_meet(
        &self,
        left: &Self::Item,
        right: &Self::Item,
    ) -> bool { ... }
    fn cover(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn disjoint(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn implies_join(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn implied_join(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn implies_meet(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
    fn implied_meet(
        &self,
        left: &SafeElement<Self::Item>,
        right: &SafeElement<Self::Item>,
    ) -> Result<bool, String> { ... }
}

General trait for lattices

Required Associated Types

type Item: Clone + Eq + HashedTypeDef

Type for encoding lattice elements:

• type Self::Item may contain element which are not in the lattice
• type SafeElement<Self::Item> contains both the element and the hash of lattice in order to assert its origin:
  • SafeElement<Self::Item> is only produced by method check_safe which control if raw element is within the lattice
  • SafeElement<Self::Item> or SafeCollection<Self::Item,I> contains checked elements;
  • Safe elements are helper, but in last ressort, the user is responsible to ensure the data validity

Required Methods

fn rand_lattice<R: Rng>(rng: &mut R) -> Self

Random lattice generator (for tests)

• rng: &mut R : random number generator
• R: Rng : type of random number generator
• Output: random lattice

fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>

Random element generator (for tests); elements are built safe

• rng: &mut R : random number generator
• R: Rng : type of random number generator
• Output: random element

fn ref_lattice_hash(&self) -> &u128slx

Reference to lattice hash

fn contains(&self, element: &Self::Item) -> bool

Test if element is from lattice

• this is necessary since type Self::Item may contain more potential elements than the lattice
• element: &Self::Item : element to be tested
• Output: boolean

fn ref_bottom(&self) -> &SafeElement<Self::Item>

Reference to least element of the lattice

• Output: reference to least element

fn ref_top(&self) -> &SafeElement<Self::Item>

Reference to greatest element of the lattice

• Output: reference to greatest element

unsafe fn unsafe_meet( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

Unsafe greatest lower bound

• values are not tested to be within lattice.
• contract: operator should be associative
• element_left: &Self::Item : left operand
• element_right: &Self::Item : right operand
• Output: unsafe greatest lower bound

unsafe fn unsafe_join( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

Unsafe least upper bound

• values are not tested to be within lattice.
• contract: operator should be associative!
• element_left: &Self::Item : left operand
• element_right: &Self::Item : right operand
• Output: unsafe least upper bound

fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>

Parse safe element from str

• s: &str : string to be parsed
• Output: parsed safe element or error

fn to_string(&self, element: &SafeElement<Self::Item>) -> Result<String, String>

Format safe element into String

• element: &SafeElement<Self::Item> : safe element to be formated into string
• Output: formated string or error

Provided Methods

fn lattice_hash(&self) -> u128slx

Lattice hash

• Output: lattice hash

fn bottom(&self) -> SafeElement<Self::Item>

Least element of the lattice

• Output: least element of the lattice

fn top(&self) -> SafeElement<Self::Item>

Greatest element of the lattice

• Output: greatest element of the lattice

fn is_bottom( &self, safe_element: &SafeElement<Self::Item>, ) -> Result<bool, String>

Is safe element the least element of the lattice?

• safe_element: &SafeElement<Self::Item> : safe element
• Output: boolean or error

fn is_top(&self, safe_element: &SafeElement<Self::Item>) -> Result<bool, String>

Is safe element the greatest element of the lattice?

• safe_element: &SafeElement<Self::Item> : safe element
• Output: boolean or error

unsafe fn unsafe_is_bottom(&self, element: &Self::Item) -> bool

Is unsafe element the least element of the lattice?

• element: &Self::Item : unsafe element
• Output: boolean or error

unsafe fn unsafe_is_top(&self, element: &Self::Item) -> bool

Is unsafe element the greatest element of the lattice?

• element: &Self::Item : unsafe element
• Output: boolean or error

fn meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<SafeElement<Self::Item>, String>

Greatest lower bound

• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: greatest lower bound or error

fn meet_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>

where I: IntoIterator<Item = &'a SafeElement<Self::Item>>, Self: 'a,

Greatest lower bound of a collection

• it: I : collection of safe elements
• I : type of collection
• Output: greatest lower bound or error

fn join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<SafeElement<Self::Item>, String>

Least upper bound

• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: least upper bound or error

fn join_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>

where I: IntoIterator<Item = &'a SafeElement<Self::Item>>, Self: 'a,

Least upper bound of a collection

• it: I : collection of safe elements
• I : type of collection
• Output: least upper bound or error

fn check_safe<T>(&self, element: T) -> Result<SafeElement<Self::Item>, String>

where T: Into<Self::Item>,

Check if unsafe element is in lattice and then build safe element

• element: T : unsafe element
• T : type of unsafe element; actually any type which implement Into<Self::Item>
• Output: safe element or error

fn rand_elements<R: Rng, I>( &self, len: usize, rng: &mut R, ) -> I::Type<SafeElement<Self::Item>>

where I: CollectionFamily1,

Elements collection generator (for tests); elements are built safe

• len: usize : size of the collection
• rng: &mut R : random number generator
• R: Rng : type of random number generator
• I : type of collection
• Output: collection of random safe elements

fn assignment(&self) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new assignment builder

• Output: empty assignment builder

fn assignment_with_capacity( &self, capacity: usize, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new assignment builder with capacity

• capacity: usize : capacity
• Output: empty assignment builder with capacity capacity

fn prunable( &self, length_mid: u32, length_max: u32, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new prunable assignment builder

• length_mid: u32slx : max size of pruned assignment
• length_max: u32slx : max size of assignment
• Output: empty assignment builder

fn prunable_with_capacity( &self, length_mid: u32, length_max: u32, capacity: usize, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new prunable assignment builder with capacity

• length_mid: u32slx : max size of pruned assignment
• length_max: u32slx : max size of assignment
• capacity: usize : capacity
• Output: empty assignment builder with capacity capacity

unsafe fn unsafe_cover(&self, left: &Self::Item, right: &Self::Item) -> bool

Unsafe test if left and right cover top, ie. union of left and right is top

• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

unsafe fn unsafe_disjoint(&self, left: &Self::Item, right: &Self::Item) -> bool

Unsafe test if left and right are disjoint

• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

unsafe fn unsafe_implies_join( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left implies (i.e. is contained by) right

• should be equivalent to implies_meet
• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

unsafe fn unsafe_implied_join( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left is implied by (i.e. contains) right

• should be equivalent to implied_meet
• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

unsafe fn unsafe_implies_meet( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left implies (i.e. is contained by) right

• should be equivalent to implies_join
• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

unsafe fn unsafe_implied_meet( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left is implied by (i.e. contains) right

• should be equivalent to implied_joint
• left: &Self::Item : left operand
• right: &Self::Item : right operand
• Output: boolean

fn cover( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left and right cover top, ie. union of left and right is top

• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

fn disjoint( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left and right are disjoint

• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

fn implies_join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left implies (i.e. is contained by) right

• should be equivalent to implies_meet
• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

fn implied_join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left is implied by (i.e. contains) right

• should be equivalent to implied_meet
• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

fn implies_meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left implies (i.e. is contained by) right

• should be equivalent to implies_join
• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

fn implied_meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left is implied by (i.e. contains) right

• should be equivalent to implied_joint
• left: &SafeElement<Self::Item> : left operand
• right: &SafeElement<Self::Item> : right operand
• Output: boolean or error

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<L> Lattice for Box<L>

where L: Lattice,

type Item = <L as Lattice>::Item

fn rand_lattice<R: Rng>(rng: &mut R) -> Self

fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>

fn ref_lattice_hash(&self) -> &u128slx

fn contains(&self, element: &Self::Item) -> bool

fn ref_bottom(&self) -> &SafeElement<Self::Item>

fn ref_top(&self) -> &SafeElement<Self::Item>

unsafe fn unsafe_meet( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

unsafe fn unsafe_join( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>

fn to_string(&self, element: &SafeElement<Self::Item>) -> Result<String, String>

impl<L> Lattice for Rc<L>

where L: Lattice,

type Item = <L as Lattice>::Item

fn rand_lattice<R: Rng>(rng: &mut R) -> Self

fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>

fn ref_lattice_hash(&self) -> &u128slx

fn contains(&self, element: &Self::Item) -> bool

fn ref_bottom(&self) -> &SafeElement<Self::Item>

fn ref_top(&self) -> &SafeElement<Self::Item>

unsafe fn unsafe_meet( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

unsafe fn unsafe_join( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>

fn to_string(&self, element: &SafeElement<Self::Item>) -> Result<String, String>

impl<L> Lattice for Arc<L>

where L: Lattice,

type Item = <L as Lattice>::Item

fn rand_lattice<R: Rng>(rng: &mut R) -> Self

fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>

fn ref_lattice_hash(&self) -> &u128slx

fn contains(&self, element: &Self::Item) -> bool

fn ref_bottom(&self) -> &SafeElement<Self::Item>

fn ref_top(&self) -> &SafeElement<Self::Item>

unsafe fn unsafe_meet( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

unsafe fn unsafe_join( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>

fn to_string(&self, element: &SafeElement<Self::Item>) -> Result<String, String>

Implementors

impl Lattice for EnumLattice

type Item = u128slx

impl Lattice for Powerset

type Item = u128slx

impl Lattice for Taxonomy

type Item = u128slx