Struct LatticeBimorphismPull 

pub struct LatticeBimorphismPull<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output> { /* private fields */ }

Pull combinator for lattice bimorphism operations.

Implementations

impl<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output> LatticeBimorphismPull<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output>

where Func: 'a + LatticeBimorphism<LhsState, RhsPrev::Item, Output = Output> + LatticeBimorphism<LhsPrev::Item, RhsState, Output = Output>, LhsPrev: 'a + FusedPull, RhsPrev: 'a + FusedPull, LhsState: 'static + Clone, RhsState: 'static + Clone, Output: Merge<Output>,

pub fn new( lhs_prev: LhsPrev, rhs_prev: RhsPrev, func: Func, lhs_state: &'a RefCell<LhsState>, rhs_state: &'a RefCell<RhsState>, ) -> Self

Creates a new LatticeBimorphismPull.

Trait Implementations

impl<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output> Pull for LatticeBimorphismPull<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output>

where Func: 'a + LatticeBimorphism<LhsState, RhsPrev::Item, Output = Output> + LatticeBimorphism<LhsPrev::Item, RhsState, Output = Output>, LhsPrev: 'a + FusedPull, RhsPrev: 'a + FusedPull, LhsState: 'static + Clone, RhsState: 'static + Clone, Output: Merge<Output>,

type Ctx<'ctx> = <<LhsPrev as Pull>::Ctx<'ctx> as Context<'ctx>>::Merged<<RhsPrev as Pull>::Ctx<'ctx>>

The context type required to poll this pull.

type Item = Output

The type of items yielded by this pull.

type Meta = ()

The metadata type associated with each item.

type CanPend = <<LhsPrev as Pull>::CanPend as Toggle>::Or<<RhsPrev as Pull>::CanPend>

Whether this pull can return [Step::Pending].

type CanEnd = <<LhsPrev as Pull>::CanEnd as Toggle>::And<<RhsPrev as Pull>::CanEnd>

Whether this pull can return [Step::Ended].

fn pull( self: Pin<&mut Self>, ctx: &mut Self::Ctx<'_>, ) -> Step<Self::Item, Self::Meta, Self::CanPend, Self::CanEnd>

Attempts to pull the next item from this stream.

fn size_hint(self: Pin<&Self>) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the pull.

fn by_ref(&mut self) -> &mut Self

Borrows this pull, allowing it to be used by reference.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a pull which gives the current iteration count as well as the next value.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates a pull that both filters and maps.

fn flat_map<U, F>( self, f: F, ) -> FlatMap<Self, F, <U as IntoIterator>::IntoIter, Self::Meta>

where Self: Sized, F: FnMut(Self::Item) -> U, U: IntoIterator,

Creates a pull that works like map, but flattens nested structure.

fn flatten( self, ) -> Flatten<Self, <Self::Item as IntoIterator>::IntoIter, Self::Meta>

where Self: Sized, Self::Item: IntoIterator,

Creates a pull that flattens nested structure.

fn for_each<F>(self, f: F) -> ForEach<Self, F>

where Self: Sized, F: FnMut(Self::Item),

Creates a future which runs the given function on each element of a pull.

fn collect<C>(self) -> Collect<Self, C>

where Self: Sized, C: Default + Extend<Self::Item>,

Creates a future which collects all elements of a pull into a collection.

fn fuse(self) -> impl for<'ctx> FusedPull

where Self: Sized,

Creates a pull that ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of a pull, passing the value on.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates a pull that calls that closure on each element.

fn send_sink<Push>(self, push: Push) -> SendSink<Self, Push>

where Self: Sized, Push: Sink<Self::Item>,

Creates a future that pulls all items and sends them into a [Sink].

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates a pull that skips the first n elements.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that skips elements based on a predicate.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates a pull that yields the first n elements, or fewer if the underlying pull ends sooner.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that yields elements based on a predicate.

fn next(self) -> Next<Self>

where Self: Sized,

Creates a future that resolves with the next item from this pull.

fn cross_singleton<SinglePull>( self, singleton_pull: SinglePull, ) -> CrossSingleton<Self, SinglePull, Option<<SinglePull as Pull>::Item>>

where Self: Sized, SinglePull: Pull, <SinglePull as Pull>::Item: Clone,

Crosses each item from this pull with a singleton value from another pull.

fn cross_singleton_state<SinglePull>( self, singleton_pull: SinglePull, singleton_state: &mut Option<<SinglePull as Pull>::Item>, ) -> CrossSingleton<Self, SinglePull, &mut Option<<SinglePull as Pull>::Item>>

where Self: Sized, SinglePull: Pull, <SinglePull as Pull>::Item: Clone,

[Self::cross_singleton] with external state.

impl<'__pin, 'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output> Unpin for LatticeBimorphismPull<'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output>

where PinnedFieldsOf<__Origin<'__pin, 'a, Func, LhsPrev, RhsPrev, LhsState, RhsState, Output>>: Unpin,