Struct Mapped 

pub struct Mapped<A, F> {
    pub inner: A,
    pub map: F,
}

Symbol-renaming view of an automaton.

Mapped is useful when an automaton should be queried under a different external signature. The mapping is applied to every input symbol before the wrapped automaton is queried. States are unchanged.

Fields

inner: A

Wrapped automaton.

map: F

Function from external symbol IDs to the wrapped automaton’s symbol IDs.

Implementations

impl<A, F> Mapped<A, F>

pub fn new(inner: A, map: F) -> Self

Create a mapped view.

Trait Implementations

impl<A, F> BottomUpTa for Mapped<A, F>

where A: BottomUpTa, F: Fn(Symbol) -> Symbol,

type State = <A 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, F: Clone> Clone for Mapped<A, F>

fn clone(&self) -> Mapped<A, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Copy, F: Copy> Copy for Mapped<A, F>

impl<A: Debug, F: Debug> Debug for Mapped<A, F>

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

Formats the value using the given formatter.

impl<A, F> DetBottomUpTa for Mapped<A, F>

where A: DetBottomUpTa, F: Fn(Symbol) -> Symbol,

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, F: Eq> Eq for Mapped<A, F>

impl<A, F> IndexedBottomUpTa for Mapped<A, F>

where A: IndexedBottomUpTa, F: Fn(Symbol) -> Symbol,

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, F: PartialEq> PartialEq for Mapped<A, F>

fn eq(&self, other: &Mapped<A, F>) -> 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, F: PartialEq> StructuralPartialEq for Mapped<A, F>