Struct IndexedCoproduct 

#[non_exhaustive]
pub struct IndexedCoproduct<K: ArrayKind, F> {
    pub sources: FiniteFunction<K>,
    pub values: F,
}

A finite coproduct of arrows of type A. Pragmatically, it’s a segmented array

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

sources: FiniteFunction<K>

A [‘FiniteFunction’] whose sum is the length of values, and whose target is sum + 1.

values: F

The concatenation of all arrays in the coproduct.

Implementations

impl<K: ArrayKind, F: Clone + HasLen<K>> IndexedCoproduct<K, F>

where K::Type<K::I>: NaturalArray<K>,

pub fn new(sources: FiniteFunction<K>, values: F) -> Option<Self>

Create a new IndexedCoproduct from a FiniteFunction whose target is the sum of its elements. This condition is checked by summing the array.

pub fn from_semifinite( sources: SemifiniteFunction<K, K::I>, values: F, ) -> Option<Self>

Create a IndexedCoproduct from an array of sources by computing their sum to create a FiniteFunction.

impl<K: ArrayKind, F: Clone + HasLen<K>> IndexedCoproduct<K, F>

where K::Type<K::I>: NaturalArray<K>,

pub fn singleton(values: F) -> Self

Construct a segmented array with a single segment containing values.

pub fn elements(values: F) -> Self

Construct a segmented array with values.len() segments, each containing a single element.

pub fn len(&self) -> K::I

pub fn flatmap_sources<G: Clone>( &self, other: &IndexedCoproduct<K, G>, ) -> IndexedCoproduct<K, G>

Like IndexedCoproduct::flatmap, but where the values of other are already mapped.

Conceptually, suppose we have

self : [[T]]
other: [[U]]

where other defines a sublist for each element of join(self). Then self.flatmap_sources(other) merges sublists of other using the sources of self.

impl<K: ArrayKind> IndexedCoproduct<K, FiniteFunction<K>>

where K::Type<K::I>: NaturalArray<K>,

pub fn initial(target: K::I) -> Self

The initial object, i.e., the finite coproduct indexed by the empty set Note that the target of sources must be zero for laws to work here.

pub fn tensor( &self, other: &IndexedCoproduct<K, FiniteFunction<K>>, ) -> IndexedCoproduct<K, FiniteFunction<K>>

pub fn map_values(&self, x: &FiniteFunction<K>) -> Option<Self>

Map the values array of an indexed coproduct, leaving the sources unchanged.

Given an indexed coproduct

Σ_{i ∈ I} f_i : Σ_{i ∈ I} A_i → B

and a finite function x : B → C, return a new IndexedCoproduct representing

Σ_{i ∈ I} (f_i ; x) : Σ_{i ∈ I} A_i → C

Returns None if x.source() != B.

pub fn map_semifinite<T>( &self, x: &SemifiniteFunction<K, T>, ) -> Option<IndexedCoproduct<K, SemifiniteFunction<K, T>>>

where K::Type<T>: Array<K, T>,

Same as map_values, but for SemifiniteFunction.

pub fn flatmap(&self, other: &Self) -> Self

Compose two IndexedCoproduct thought of as lists-of-lists. Given

self : Σ_{a ∈ A} s(a) → B      aka A → B*
other : Σ_{b ∈ B} s(b) → C      aka B → C*

we obtain

self.flatmap(other) : Σ_{a ∈ A} s(a) → C     aka A → C*

impl<K: ArrayKind, F> IndexedCoproduct<K, F>

where K::Type<K::I>: NaturalArray<K>, F: HasLen<K> + Clone, for<'a, 'b> &'a FiniteFunction<K>: Shr<&'b F, Output = Option<F>>, for<'a, 'b> &'a F: Add<&'b F, Output = Option<F>>,

pub fn coproduct(&self, other: &Self) -> Option<Self>

pub fn map_indexes(&self, x: &FiniteFunction<K>) -> Option<Self>

Given an IndexedCoproduct of SemifiniteFunction:

Σ_{i ∈ X} f_i : Σ_{i ∈ X} A_i → B

and a finite function x : W → X

Return a new IndexedCoproduct representing

Σ_{i ∈ W} f_{x(i)} : Σ_{i ∈ W} A_{x(i)} → B

pub fn indexed_values(&self, x: &FiniteFunction<K>) -> Option<F>

Like Self::map_indexes but only returns the values array.

Trait Implementations

impl<K: ArrayKind, F: Clone> Clone for IndexedCoproduct<K, F>

where K::Type<K::I>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: ArrayKind, F: Debug> Debug for IndexedCoproduct<K, F>

where K::Index: Debug,

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

Formats the value using the given formatter.

impl<K: ArrayKind, F> HasLen<K> for IndexedCoproduct<K, F>

where K::Type<K::I>: NaturalArray<K>,

fn len(&self) -> K::I

fn is_empty(&self) -> bool

impl<K: ArrayKind> IntoIterator for IndexedCoproduct<K, FiniteFunction<K>>

where K::Type<K::I>: NaturalArray<K>, K::I: Into<usize>,

type Item = FiniteFunction<K>

The type of the elements being iterated over.

type IntoIter = IndexedCoproductFiniteFunctionIterator<K>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: ArrayKind, T> IntoIterator for IndexedCoproduct<K, SemifiniteFunction<K, T>>

where K::Type<K::I>: NaturalArray<K>, K::Type<T>: Array<K, T>, K::I: Into<usize>,

type Item = SemifiniteFunction<K, T>

The type of the elements being iterated over.

type IntoIter = IndexedCoproductSemifiniteFunctionIterator<K, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: ArrayKind, F: PartialEq> PartialEq for IndexedCoproduct<K, F>

fn eq(&self, other: &Self) -> 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.