Struct Transducerdp 

pub struct Transducerdp<M, T, C>
where
    M: Monoid,
    T: Transducer,
    C: Container<Key = T::State, Value = M::T>,
{
    fst: T,
    pub dp: C,
    ndp: C,
    _marker: PhantomData<fn() -> M>,
}

Fields

fst: T

dp: C

ndp: C

_marker: PhantomData<fn() -> M>

Implementations

impl<M, T, C> Transducerdp<M, T, C>

where M: Monoid, T: Transducer, C: Container<Key = T::State, Value = M::T>,

pub fn new<F>(fst: T, init: M::T, factory: F) -> Self

where F: ContainerFactory<Container = C>,

Examples found in repository

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

    pub fn with_factory<F>(self, factory: F) -> Transducerdp<M, A, F::Container>
    where
        F: ContainerFactory<Container: Container<Key = A::State, Value = M::T>>,
    {
        Transducerdp::new(self.fst, self.init, factory)
    }

pub fn step<S, I, B>(&mut self, sigma: S)

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>,

Examples found in repository

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

    pub fn run<S, I, B>(&mut self, mut sigma: S, len: usize) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
    {
        for _ in 0..len {
            self.step(&mut sigma);
        }
        self.fold_accept()
    }

pub fn step_effect<S, I, B, F>(&mut self, sigma: S, effect: F)

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>, F: FnMut(&M::T, &T::Output) -> M::T,

Examples found in repository

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

    pub fn run_effect<S, I, B, F>(&mut self, mut sigma: S, len: usize, mut effect: F) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
        F: FnMut(&M::T, &T::Output) -> M::T,
    {
        for _ in 0..len {
            self.step_effect(&mut sigma, &mut effect);
        }
        self.fold_accept()
    }

pub fn fold_accept(&self) -> M::T

Examples found in repository

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

    pub fn run<S, I, B>(&mut self, mut sigma: S, len: usize) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
    {
        for _ in 0..len {
            self.step(&mut sigma);
        }
        self.fold_accept()
    }
    pub fn run_effect<S, I, B, F>(&mut self, mut sigma: S, len: usize, mut effect: F) -> M::T
    where
        S: FnMut() -> I,
        I: IntoIterator<Item = B>,
        B: Borrow<T::Input>,
        F: FnMut(&M::T, &T::Output) -> M::T,
    {
        for _ in 0..len {
            self.step_effect(&mut sigma, &mut effect);
        }
        self.fold_accept()
    }

pub fn map_fold_accept<U, F, D>(&self, f: F, map: D) -> D

where F: FnMut(&T::State) -> U, D: Container<Key = U, Value = M::T>,

pub fn run<S, I, B>(&mut self, sigma: S, len: usize) -> M::T

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>,

pub fn run_effect<S, I, B, F>( &mut self, sigma: S, len: usize, effect: F, ) -> M::T

where S: FnMut() -> I, I: IntoIterator<Item = B>, B: Borrow<T::Input>, F: FnMut(&M::T, &T::Output) -> M::T,

Trait Implementations

impl<M, T, C> Clone for Transducerdp<M, T, C>

where M: Monoid + Clone, T: Transducer + Clone, C: Container<Key = T::State, Value = M::T> + Clone,

fn clone(&self) -> Transducerdp<M, T, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, T, C> Debug for Transducerdp<M, T, C>

where M: Monoid<T: Debug>, T: Transducer<State: Debug> + Debug, C: Container<Key = T::State, Value = M::T> + Debug,

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

Formats the value using the given formatter.