Struct StringDecompositionAutomaton 

pub struct StringDecompositionAutomaton { /* private fields */ }

Lazy CKY-style string decomposition automaton.

Implementations

impl StringDecompositionAutomaton

pub fn new(concat: Symbol, sentence: Vec<Symbol>) -> Self

Build a lazy decomposition automaton for sentence.

pub fn concat_symbol(&self) -> Symbol

Return the concat operation symbol.

pub fn len(&self) -> usize

Return the sentence length.

pub fn sentence(&self) -> &[Symbol]

Return the sentence tokens (used by the obligatory-leaf F heuristic to build per-input terminal supply).

pub fn is_empty(&self) -> bool

Return whether the sentence is empty.

pub fn rule_count(&self) -> usize

Count explicit CKY-style decomposition rules without materializing them.

Trait Implementations

impl BottomUpTa for StringDecompositionAutomaton

type State = Span

State type carried by the automaton.

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

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

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

Return whether q is an accepting state.

impl Clone for StringDecompositionAutomaton

fn clone(&self) -> StringDecompositionAutomaton

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CondensedTa for StringDecompositionAutomaton

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

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, Span))

Enumerate condensed nullary rules.

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

Enumerate condensed rules whose child at position is state.

impl Debug for StringDecompositionAutomaton

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

Formats the value using the given formatter.

impl DetBottomUpTa for StringDecompositionAutomaton

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

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 StringDecompositionAutomaton

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

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

impl IntersectionHeuristic<StringDecompositionAutomaton> for SentenceSxHeuristic<'_>

fn outside_estimate(&self, left: StateId, span: &Span) -> f64

Return an optimistic (admissible) upper bound in (0, 1] on the best outside weight of any completion around product state (left, right).

fn admits(&self, _left: StateId, _right: &R::State) -> bool

Sound hard filter consulted at candidate-construction time: return false iff (left, right) provably has zero outside weight (it can appear in no valid completion), so the A* loop may skip building the edge entirely rather than merely deprioritizing it.

fn estimate_if_admitted(&self, left: StateId, right: &R::State) -> Option<f64>

Return the outside estimate when the product is admitted, and None when it is provably unable to occur in an accepting derivation.

fn memoize_admission(&self) -> bool

Whether A* should memoize the admission decision by product pair.

fn estimate_after_admission(&self, left: StateId, right: &R::State) -> f64

Return the outside estimate when admission for this pair is already known to succeed.

impl IntersectionHeuristic<StringDecompositionAutomaton> for ObligatoryLeafHeuristic<'_>

fn outside_estimate(&self, left: StateId, span: &Span) -> f64

Return an optimistic (admissible) upper bound in (0, 1] on the best outside weight of any completion around product state (left, right).

fn admits(&self, left: StateId, span: &Span) -> bool

Sound hard filter consulted at candidate-construction time: return false iff (left, right) provably has zero outside weight (it can appear in no valid completion), so the A* loop may skip building the edge entirely rather than merely deprioritizing it.

fn estimate_if_admitted(&self, left: StateId, span: &Span) -> Option<f64>

Return the outside estimate when the product is admitted, and None when it is provably unable to occur in an accepting derivation.

fn memoize_admission(&self) -> bool

Whether A* should memoize the admission decision by product pair.

fn estimate_after_admission(&self, _left: StateId, _span: &Span) -> f64

Return the outside estimate when admission for this pair is already known to succeed.

impl StateUniverse for StringDecompositionAutomaton

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

Report every state in the finite universe exactly once.

impl TopDownTa for StringDecompositionAutomaton

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

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

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

Report the initial states of the top-down view.