Struct AcceptTransducer 

pub struct AcceptTransducer<T, F> {
    inner: T,
    pred: F,
}

Fields

inner: T

pred: F

Implementations

impl<T, F> AcceptTransducer<T, F>

pub fn new(inner: T, pred: F) -> Self

Examples found in repository

crates/competitive/src/data_structure/transducer.rs (line 108)

    fn accepting<F>(self, pred: F) -> AcceptTransducer<Self, F>
    where
        Self: Sized,
        F: Fn(&Self::State) -> bool,
    {
        AcceptTransducer::new(self, pred)
    }

Trait Implementations

impl<T: Clone, F: Clone> Clone for AcceptTransducer<T, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, F: Debug> Debug for AcceptTransducer<T, F>

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

Formats the value using the given formatter.

impl<T, F> Transducer for AcceptTransducer<T, F>

where T: Transducer, F: Fn(&T::State) -> bool,

type Input = <T as Transducer>::Input

type Output = <T as Transducer>::Output

type State = <T as Transducer>::State

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) -> MapTransducer<Self, U, F>

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

fn try_map<U, F>(self, f: F) -> TryMapTransducer<Self, U, F>

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

fn retain<F>(self, pred: F) -> RetainTransducer<Self, F>

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

fn with_fold<A, F>(self, init: A, f: F) -> FoldTransducer<Self, A, F>

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

fn with_try_fold<A, F>(self, init: A, f: F) -> TryFoldTransducer<Self, A, F>

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

fn accepting<F>(self, pred: F) -> AcceptTransducer<Self, F>

where Self: Sized, F: Fn(&Self::State) -> bool,