Enum AggregateRule 

pub enum AggregateRule {
    ExhaustiveExactlyOnce,
    NoRepeat,
    DeclaredMultiplicity(DeclaredCounts),
    DeclaredOmissions(DeclaredCounts),
    ProjectedAggregate(ProjectedRule),
    FreeOrder,
}

Aggregate rule data compiled from symbols into private canonical positions. Callers never provide raw ordinals.

Variants

ExhaustiveExactlyOnce

Every alphabet symbol occurs exactly once.

NoRepeat

Symbols may be omitted but no symbol may repeat.

DeclaredMultiplicity(DeclaredCounts)

Explicit per-symbol multiplicity data.

DeclaredOmissions(DeclaredCounts)

Explicit set of omitted symbols; every other symbol occurs once.

ProjectedAggregate(ProjectedRule)

Explicit projection classes and their required multiplicities.

FreeOrder

Any finite order of alphabet members, including repeats.

Implementations

impl AggregateRule

pub const fn exhaustive_exactly_once() -> AggregateRule

Constructs an exhaustive exactly-once rule.

pub const fn no_repeat() -> AggregateRule

Constructs a no-repeat rule.

pub const fn free_order() -> AggregateRule

Constructs a free-order rule.

pub fn declared_multiplicity<A, I>( alphabet: &A, declarations: I, ) -> Result<AggregateRule, AggregateRuleError>

where A: SerialAlphabet, I: IntoIterator<Item = (<A as SerialAlphabet>::Symbol, usize)>,

Compiles an explicit positive multiplicity for every alphabet symbol.

pub fn declared_omissions<A, I>( alphabet: &A, omissions: I, ) -> Result<AggregateRule, AggregateRuleError>

where A: SerialAlphabet, I: IntoIterator<Item = <A as SerialAlphabet>::Symbol>,

Compiles a set of symbols to omit; every remaining symbol is required once.

pub fn projected_aggregate<A, I>( alphabet: &A, classes: I, ) -> Result<AggregateRule, AggregateRuleError>

where A: SerialAlphabet, I: IntoIterator<Item = ProjectedClassSpec<<A as SerialAlphabet>::Symbol>>,

Compiles a complete, disjoint projection of alphabet symbols into classes.

pub const fn kind(&self) -> AggregateRuleKind

Returns the public category of this rule.

pub fn declared_counts<A>( &self, alphabet: &A, ) -> Result<Option<Vec<(<A as SerialAlphabet>::Symbol, usize)>>, AggregateRuleError>

where A: SerialAlphabet,

Returns symbol/count declarations for a declared multiplicity or omission rule.

pub fn projected_classes<A>( &self, alphabet: &A, ) -> Result<Option<Vec<ProjectedClassSpec<<A as SerialAlphabet>::Symbol>>>, AggregateRuleError>

where A: SerialAlphabet,

Returns symbolic projected-class declarations for a projected rule.

Trait Implementations

impl Clone for AggregateRule

fn clone(&self) -> AggregateRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateRule

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

Formats the value using the given formatter.

impl Eq for AggregateRule

impl PartialEq for AggregateRule

fn eq(&self, other: &AggregateRule) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AggregateRule