Struct Uniform 

pub struct Uniform<P, F: Set> { /* private fields */ }

One-route representation with no route discriminant.

Implementations

impl<P, F: Set> Uniform<P, F>

pub const fn new(prep: P, body: Body<F::SyncOpen, F::SyncFinished>) -> Self

impl<P> Uniform<P, Admitted>

pub fn into_request( self, ) -> Body<Admitted<Sync, P, Track<Open>>, Admitted<Sync, P, Track<Finished>>>

Trait Implementations

impl<P, F, G> Admission<P, F, G> for Uniform<P, F>

where F: Set, G: Set,

type Output = Uniform<P, G>

fn admit<V: Visit<P, F, G>>( self, visit: &mut V, ) -> ControlFlow<V::Break, Self::Output>

impl<P, F: Set> Flow<F> for Uniform<P, F>

fn fold<T: Fold<F>>(self, fold: T) -> T::Output

impl<P, F: Set> Flow<P, F> for Uniform<P, F>

type Family = Uniforms<P>

fn each<'a, M: Each<P, F>>(&'a mut self, each: M) -> M::Output<'a>

fn map_retain<G: Set, M: Map<P, F, G>>( self, map: M, ) -> ControlFlow<M::Break, (M::Retained, Uniform<P, G>)>

fn fold<T: Fold<P, F>>(self, fold: T) -> T::Output

fn finish(self) -> Result<Self, Self>

where F: Finish,

Retags an open route arm as finished while retaining the same route, slot, payload owner, and generated-family discriminant storage.

fn each_open<'a, V: Each<F>>(&'a mut self, visit: V) -> V::Output<'a>

where F: Set,

fn fold_open<V: Fold<P, F>>(self, visit: V) -> V::Output

where F: Set,

fn consume<O, V: FnOnce(F::Body) -> O>(self, visit: V) -> O

where F: Set,

fn map<G: Set, M: Map<P, F, G, Retained = ()>>( self, map: M, ) -> ControlFlow<M::Break, <Self::Family as Family<P>>::State<G>>