Struct FunctionalTransducer

pub struct FunctionalTransducer<I, O, S, F, G, H>
where
    F: Fn() -> S,
    G: Fn(&S, &I) -> Option<(S, O)>,
    H: Fn(&S) -> bool,
{ /* private fields */ }

Implementations

impl<I, O, S, F, G, H> FunctionalTransducer<I, O, S, F, G, H>

where F: Fn() -> S, G: Fn(&S, &I) -> Option<(S, O)>, H: Fn(&S) -> bool,

pub fn new(fn_start: F, fn_relation: G, fn_accept: H) -> Self

Trait Implementations

impl<I: Clone, O: Clone, S: Clone, F, G, H> Clone for FunctionalTransducer<I, O, S, F, G, H>

where F: Fn() -> S + Clone, G: Fn(&S, &I) -> Option<(S, O)> + Clone, H: Fn(&S) -> bool + Clone,

fn clone(&self) -> FunctionalTransducer<I, O, S, F, G, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, O: Debug, S: Debug, F, G, H> Debug for FunctionalTransducer<I, O, S, F, G, H>

where F: Fn() -> S + Debug, G: Fn(&S, &I) -> Option<(S, O)> + Debug, H: Fn(&S) -> bool + Debug,

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

Formats the value using the given formatter.

impl<I, O, S, F, G, H> Transducer for FunctionalTransducer<I, O, S, F, G, H>

where F: Fn() -> S, G: Fn(&S, &I) -> Option<(S, O)>, H: Fn(&S) -> bool,

type Input = I

type Output = O

type State = S

fn start(&self) -> Self::State

fn relation( &self, state: &Self::State, input: &Self::Input, ) -> Option<(Self::State, Self::Output)>

fn accept(&self, state: &Self::State) -> bool

fn stepout(&mut self)

fn dp<M>(self, init: M::T) -> InitTransducerDp<M, Self>

where Self: Sized, M: Monoid,

fn intersection<U>(self, other: U) -> IntersectionTransducer<(Self, U)>

where Self: Sized, U: Transducer<Input = Self::Input>,

fn product<U>(self, other: U) -> ProductTransducer<(Self, U)>

where Self: Sized, U: Transducer,

fn chain<U>(self, other: U) -> ChainTransducer<(Self, U)>

where Self: Sized, U: Transducer<Input = Self::Output>,

fn with_input( self, ) -> IntersectionTransducer<(Self, IdentityTransducer<Self::Input>)>

where Self: Sized,

fn map<U, F>( self, f: F, ) -> ChainTransducer<(Self, MapTransducer<Self::Output, U, F>)>

where Self: Sized, F: Fn(&Self::Output) -> U,

fn filter_map<U, F>( self, f: F, ) -> ChainTransducer<(Self, FilterMapTransducer<Self::Output, U, F>)>

where Self: Sized, F: Fn(&Self::Output) -> Option<U>,