Struct Explicit 

pub struct Explicit { /* private fields */ }

A fully materialized bottom-up tree automaton.

Explicit stores transition rules in lookup tables. It is the fastest representation when all rules are known ahead of time or after an implicit automaton has been materialized. Rules with arity 0, 1, and 2 use separate compact tables because those are the common hot paths.

Build values with ExplicitBuilder. Every transition rule has a weight; callers that do not have natural weights can use 1.0.

Implementations

impl Explicit

pub fn application_summary(&self) -> AutomatonSummary

Return an owned summary without exposing internal indexes.

pub fn language_cardinality(&self) -> LanguageCardinality

Return the number of accepted derivation trees without enumerating them.

pub fn resolve_rules( &self, state_name: impl FnMut(StateId) -> String, symbol_name: impl FnMut(Symbol) -> String, ) -> Vec<ResolvedRule>

Resolve rules with caller-supplied state and symbol naming.

pub fn resolved_rule( &self, index: usize, state_name: impl FnMut(StateId) -> String, symbol_name: impl FnMut(Symbol) -> String, ) -> ResolvedRule

Resolve a single rule by index with caller-supplied naming.

impl Explicit

pub fn num_states(&self) -> u32

Return the number of allocated states.

pub fn num_rules(&self) -> usize

Return the number of transition rules in this automaton.

pub fn is_empty(&self) -> bool

Return true if no tree can be accepted by this automaton.

This computes reachable states from nullary rules and checks whether any accepting state is reachable.

pub fn reachable_states(&self) -> FixedBitSet

Compute states reachable from nullary rules by saturation.

A state is reachable if some finite tree can receive that state at its root. This is often useful for pruning or quick emptiness checks. The result is cached after the first call because explicit automata are immutable.

pub fn rules(&self) -> impl Iterator<Item = Rule<'_>>

Iterate over all transition rules.

The order is stable for a fixed automaton but should not be treated as a semantic ordering.

pub fn rules_topdown(&self, parent: StateId) -> impl Iterator<Item = Rule<'_>>

Iterate over rules with the given parent/result state.

pub fn rule(&self, rule_idx: usize) -> Rule<'_>

Return the transition rule at the given index.

Provides O(1) indexed access to a borrowed view of a rule; the children slice is not copied. The index must be less than Self::num_rules; passing an out-of-bounds index panics. Rule order matches the order produced by Self::rules.

impl Explicit

pub fn sorted_language(&self) -> SortedLanguageIterator<'_>

Iterate over accepted trees in descending rule-weight product order.

impl Explicit

pub fn viterbi(&self) -> Option<ViterbiTree>

Compute the highest-weighted accepted tree.

This is a direct one-best dynamic program for acyclic parse charts. It deliberately avoids the k-best sorted-language machinery when callers only need the best derivation. Cyclic dependencies on the active DFS path are ignored: for PCFG-style rule weights below one, traversing a cycle cannot improve a finite derivation. Direct self-loops are skipped for the same reason, matching Alto’s convention.

pub fn viterbi_with<S: WeightScorer>(&self, scorer: &S) -> Option<ViterbiTree>

Compute the highest-scoring accepted tree under scorer.

Trait Implementations

impl BottomUpTa for Explicit

type State = StateId

State type carried by the automaton.

fn step(&self, f: Symbol, children: &[StateId], out: &mut dyn FnMut(StateId))

Report all possible parent states for f(children...).

fn is_accepting(&self, q: &StateId) -> bool

Return whether q is an accepting state.

impl Clone for Explicit

fn clone(&self) -> Explicit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CondensedTa for Explicit

fn condensed_rules(&self, out: &mut dyn FnMut(&[StateId], &SymbolSet, StateId))

Enumerate every distinct (children, result) pair, reporting the set of symbols that have that shape.

fn condensed_nullary_rules(&self, out: &mut dyn FnMut(&SymbolSet, StateId))

Enumerate condensed nullary rules.

fn condensed_rules_by_child( &self, position: usize, state: &StateId, out: &mut dyn FnMut(&[StateId], &SymbolSet, StateId), )

Enumerate condensed rules whose child at position is state.

impl CondensedTopDownTa for Explicit

fn condensed_rules_by_parent( &self, parent: &StateId, out: &mut dyn FnMut(&SymbolSet, &[StateId]), )

Report every condensed rule symbols(children...) -> parent.

fn condensed_initial_states(&self, out: &mut dyn FnMut(StateId))

Report initial states of the top-down view.

impl Debug for Explicit

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

Formats the value using the given formatter.

impl DetBottomUpTa for Explicit

fn step_det(&self, f: Symbol, children: &[StateId]) -> Option<StateId>

Return the unique result state, or None if no transition exists.

fn det_group(&self, f: Symbol) -> u32

Group key for symbols that share a transition function.

impl IndexedBottomUpTa for Explicit

fn step_partial( &self, f: Symbol, position: usize, state_at_position: &StateId, out: &mut dyn FnMut(&[StateId], StateId), )

Report every rule f(children...) -> q where children[position] equals state_at_position.

impl StateUniverse for Explicit

fn all_states(&self, out: &mut dyn FnMut(StateId))

Report every state in the finite universe exactly once.

impl TopDownTa for Explicit

fn step_topdown( &self, parent: &StateId, out: &mut dyn FnMut(Symbol, &[StateId]), )

Report every rule f(children...) -> parent.

fn initial_states(&self, out: &mut dyn FnMut(StateId))

Report the initial states of the top-down view.