Struct LexicographicalTransducer 

pub struct LexicographicalTransducer<T> {
    ordering: Ordering,
    equal: bool,
    _marker: PhantomData<fn() -> T>,
}

DFA to accept Less/Greater than (or equal to) in lexicographical order

Fields

ordering: Ordering

equal: bool

_marker: PhantomData<fn() -> T>

Implementations

impl<T> LexicographicalTransducer<T>

pub fn less_than() -> Self

pub fn less_than_or_equal() -> Self

pub fn greater_than() -> Self

pub fn greater_than_or_equal() -> Self

Trait Implementations

impl<T: Clone> Clone for LexicographicalTransducer<T>

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> Debug for LexicographicalTransducer<T>

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

Formats the value using the given formatter.

impl<T> Transducer for LexicographicalTransducer<T>

where T: Ord,

type State = bool

is equal

type Input = (T, T)

type Output = ()

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,