Struct Product 

pub struct Product<A, B>(pub A, pub B);

Intersection product of two bottom-up automata.

Product(a, b) accepts exactly the trees accepted by both component automata. Its state is a pair (state_from_a, state_from_b).

The generic BottomUpTa implementation asks both sides for possible parent states and emits their cartesian product. When both components are deterministic, Product also implements DetBottomUpTa and avoids that result-set enumeration. If both components implement IndexedBottomUpTa, the product also supports indexed rule joins for sibling-finder-style parsing algorithms.

Tuple Fields

0: A

1: B

Trait Implementations

impl<A, B> BottomUpTa for Product<A, B>

where A: BottomUpTa, B: BottomUpTa,

type State = (<A as BottomUpTa>::State, <B as BottomUpTa>::State)

State type carried by the automaton.

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

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

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

Return whether q is an accepting state.

impl<A: Clone, B: Clone> Clone for Product<A, B>

fn clone(&self) -> Product<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Copy, B: Copy> Copy for Product<A, B>

impl<A: Debug, B: Debug> Debug for Product<A, B>

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

Formats the value using the given formatter.

impl<A: Default, B: Default> Default for Product<A, B>

fn default() -> Product<A, B>

Returns the “default value” for a type.

impl<A, B> DetBottomUpTa for Product<A, B>

where A: DetBottomUpTa, B: DetBottomUpTa,

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

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<A: Eq, B: Eq> Eq for Product<A, B>

impl<A, B> IndexedBottomUpTa for Product<A, B>

where A: IndexedBottomUpTa, B: IndexedBottomUpTa,

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

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

impl<A: PartialEq, B: PartialEq> PartialEq for Product<A, B>

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

impl<A: PartialEq, B: PartialEq> StructuralPartialEq for Product<A, B>

impl<A, B> TopDownTa for Product<A, B>

where A: TopDownTa, B: TopDownTa,

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

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

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

Report the initial states of the top-down view.