Struct Set 

pub struct Set<K = IndexKey> { /* private fields */ }

A finite, ordered index set, parameterized by the type K its keys decode to.

K is a phantom marker: the runtime representation is the same erased payload regardless of K, so carrying the key type costs nothing at runtime. It exists so the variable!/constraint!/sum! macros can infer the closure parameter type from the set instead of requiring an annotation.

Supports integer ranges (K = usize), string lists (K = String), and arbitrary tuple lists (built via Set::product / the &a * &b operator.

axes is Some exactly when the set is a dense integer grid and records the per-axis extents. It is None for string sets, sparse/from_ints sets, and any filtered set.

Implementations

impl<K> Set<K>

pub fn tuples<I, T>(iter: I) -> Self

where I: IntoIterator<Item = T>, T: Into<IndexTuple>,

Build a tuple set directly from an iterator of keys.

pub fn filter<F>(&self, f: F) -> Self

where F: FnMut(&IndexKey) -> bool,

Filter keys with a predicate. Preserves the original variant where possible.

pub fn filter_typed<F>(&self, pred: F) -> Self

where K: FromIndexKey, F: FnMut(K) -> bool,

Filter keys with a predicate over the typed, by-value decoded key.

Unlike Self::filter (which hands the closure a raw IndexKey), the key is decoded to K first, so a product set yields native tuples and no manual as_tuple().unwrap() unpacking is needed. The receiver’s K pins the closure parameter, so it usually needs no annotation.

use oximo_core::Set;
let plants = Set::strings(["seattle", "san-diego"]);
// No-self-loop arcs; keys decoded to `(String, String)`.
let arcs = (&plants * &plants).filter_typed(|(p, q)| p != q);
assert_eq!(arcs.len(), 2);

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_range(&self) -> bool

Whether the backing representation is the integer-range variant.

pub fn is_strings(&self) -> bool

Whether the backing representation is the string-list variant.

pub fn is_tuples(&self) -> bool

Whether the backing representation is the tuple-list variant.

pub fn product<B>(a: &Set<K>, b: &Set<B>) -> Set<<K as KeyCat<B>>::Out>

where K: KeyCat<B>,

Cartesian product of two sets. Inner tuple keys are flattened so a product (a * b) * c yields 3-element tuples, not nested 2-tuples.

Panics

Panics if a.len() * b.len() overflows usize.

impl Set<usize>

pub fn range<T: PrimInt>(r: Range<T>) -> Self

Build an integer index set from a range over any primitive integer type. Accepts Range<i64>, Range<i32>, Range<usize>, etc.

The keys decode to usize. Negative elements are accepted into the payload but panic when decoded to usize.

Panics

Panics if either range bound does not fit in i64.

pub fn from_ints<T, I>(iter: I) -> Self

where T: PrimInt, I: IntoIterator<Item = T>,

Build an integer index set from an iterator of any primitive integer type. Useful when keys are sparse or computed.

Panics

Panics if any element does not fit in i64.

impl Set<String>

pub fn strings<I, S>(iter: I) -> Self

where I: IntoIterator<Item = S>, S: Into<SmolStr>,

impl<K> Set<K>

pub fn iter(&self) -> SetIter<'_>

pub fn par_iter(&self) -> impl ParallelIterator<Item = IndexKey> + '_

Trait Implementations

impl<K> Clone for Set<K>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K> Debug for Set<K>

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

Formats the value using the given formatter.

impl<'a, K> IntoIterator for &'a Set<K>

type Item = IndexKey

The type of the elements being iterated over.

type IntoIter = SetIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, B> Mul<&Set<B>> for &Set<A>

where A: KeyCat<B>,

type Output = Set<<A as KeyCat<B>>::Out>

The resulting type after applying the * operator.

fn mul(self, rhs: &Set<B>) -> Self::Output

Performs the * operation.

impl<K: FromIndexKey> SumDomain<K> for Set<K>

fn keys(&self) -> impl Iterator<Item = K> + '_