Struct FiniteCarrier 

pub struct FiniteCarrier<T: Ord> { /* private fields */ }

Deterministic explicit finite carrier distinct from inferred tuple support. A deterministic explicit finite carrier.

FiniteCarrier<T> is the first executable G7 carrier boundary. It records admissible values explicitly, even when some values are disconnected from the support of stored tuples. This keeps an explicit carrier semantically distinct from exact support inferred from relations such as crate::BinaryRelation::carrier. Empty and singleton carriers are ordinary first-class values rather than special cases hidden behind relation support.

The starter implementation stores carrier members in a BTreeSet, so membership and iteration are deterministic.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);
let step = BinaryRelation::from_pairs([("Draft", "Review")]);

assert!(states.contains(&"Archived"));
assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
assert_eq!(step.carrier().to_vec(), vec!["Draft", "Review"]);

Implementations

impl<T: Ord> FiniteCarrier<T>

pub fn new() -> Self

Creates an empty explicit finite carrier.

pub fn from_values<I>(values: I) -> Self

where I: IntoIterator<Item = T>,

Creates an explicit finite carrier from the provided values.

Duplicate values are coalesced into one stored member.

Examples found in repository

examples/carrier.rs (line 7)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn singleton(value: T) -> Self

Creates an explicit finite carrier containing exactly one value.

pub fn len(&self) -> usize

Returns the number of values in the explicit carrier.

pub fn is_empty(&self) -> bool

Returns true when the explicit carrier contains no values.

pub fn insert(&mut self, value: T) -> bool

Inserts a value into the explicit carrier.

Returns true when the value was not already present.

pub fn contains(&self, value: &T) -> bool

Returns true when the explicit carrier contains the given value.

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns an iterator over carrier values in deterministic order.

pub fn to_unary_relation(&self) -> UnaryRelation<T>

where T: Clone,

Materializes this explicit carrier as a unary relation.

This is an explicit bridge to the published exact APIs and generic code paths that still take UnaryRelation<T> carrier arguments, such as crate::BinaryRelation::identity and older call sites of crate::BinaryRelation::reflexive_transitive_closure.

The conversion is intentionally explicit because it forgets the semantic distinction between an explicitly declared carrier and ordinary unary relation support. For direct carrier-aware exact operations, prefer methods such as crate::BinaryRelation::identity_on and crate::BinaryRelation::reflexive_transitive_closure_on.

Examples

use relmath::{BinaryRelation, FiniteCarrier};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

assert_eq!(
    step.reflexive_transitive_closure(&states.to_unary_relation())
        .to_vec(),
    step.reflexive_transitive_closure_on(&states).to_vec()
);

Examples found in repository

examples/carrier.rs (line 30)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Converts the explicit carrier into a sorted vector of values.

Examples found in repository

examples/carrier.rs (line 27)

fn main() {
    let step = BinaryRelation::from_pairs([("Draft", "Review")]);
    let states = FiniteCarrier::from_values(["Draft", "Review", "Archived"]);

    let inferred = step.carrier();
    let inferred_identity = BinaryRelation::identity(&inferred);
    let explicit_identity = BinaryRelation::identity_on(&states);
    let reachable = step.reflexive_transitive_closure_on(&states);

    assert_eq!(inferred.to_vec(), vec!["Draft", "Review"]);
    assert_eq!(
        inferred_identity.to_vec(),
        vec![("Draft", "Draft"), ("Review", "Review")]
    );
    assert_eq!(
        explicit_identity.to_vec(),
        vec![
            ("Archived", "Archived"),
            ("Draft", "Draft"),
            ("Review", "Review"),
        ]
    );
    assert_eq!(states.to_vec(), vec!["Archived", "Draft", "Review"]);
    assert_eq!(
        reachable.to_vec(),
        step.reflexive_transitive_closure(&states.to_unary_relation())
            .to_vec()
    );
    assert!(reachable.is_reflexive_on(&states));
    assert!(step.is_irreflexive_on(&states));
    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Review"));

    println!(
        "explicit carrier: {:?}; inferred support: {:?}; inferred identity: {:?}; explicit identity: {:?}; reachable: {:?}",
        states.to_vec(),
        inferred.to_vec(),
        inferred_identity.to_vec(),
        explicit_identity.to_vec(),
        reachable.to_vec()
    );
}

Trait Implementations

impl<T: Clone + Ord> Clone for FiniteCarrier<T>

fn clone(&self) -> FiniteCarrier<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Ord> Debug for FiniteCarrier<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Ord> Default for FiniteCarrier<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Ord> Extend<T> for FiniteCarrier<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: Ord> FromIterator<T> for FiniteCarrier<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T: Ord> IntoIterator for &'a FiniteCarrier<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> IntoIterator for FiniteCarrier<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq + Ord> PartialEq for FiniteCarrier<T>

fn eq(&self, other: &FiniteCarrier<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Ord> Eq for FiniteCarrier<T>

impl<T: Ord> StructuralPartialEq for FiniteCarrier<T>