Trait Sipper 

pub trait Sipper<Output, Progress = Output>: Core<Output = Output, Progress = Progress> {
    // Provided methods
    fn with<F, A>(self, f: F) -> With<Self, F, A>
       where Self: Sized,
             F: FnMut(Progress) -> A { ... }
    fn filter_with<F, A>(self, f: F) -> FilterWith<Self, F, A>
       where Self: Sized,
             F: FnMut(Progress) -> Option<A> { ... }
    fn sip(&mut self) -> Next<'_, Self>
       where Self: Unpin { ... }
    fn run<S>(self, on_progress: impl Into<Sender<Progress, S>>) -> Run<Self, S>
       where Self: Sized,
             S: Sink<Progress> { ... }
    fn pin(self) -> Pin<Box<Self>>
       where Self: Sized { ... }
}

Available on crate feature sipper only.

A sipper is both a Stream that produces a bunch of progress and a Future that produces some final output.

Provided Methods

fn with<F, A>(self, f: F) -> With<Self, F, A>

where Self: Sized, F: FnMut(Progress) -> A,

Maps the progress of the Sipper with the given closure.

This is analogous to map in many other types; but we use with to avoid naming collisions with Future and Stream.

fn filter_with<F, A>(self, f: F) -> FilterWith<Self, F, A>

where Self: Sized, F: FnMut(Progress) -> Option<A>,

Maps and filters the progress of the Sipper with the given closure.

This is analogous to filter_map in many other types; but we use filter_with to avoid naming collisions with Future and Stream.

fn sip(&mut self) -> Next<'_, Self>

where Self: Unpin,

Returns the next progress, if any.

When this method returns None, it means there is no more progress to be made; and the output is ready.

fn run<S>(self, on_progress: impl Into<Sender<Progress, S>>) -> Run<Self, S>

where Self: Sized, S: Sink<Progress>,

Runs the Sipper, sending any progress through the given Sender and returning its output at the end.

fn pin(self) -> Pin<Box<Self>>

where Self: Sized,

Pins the Sipper in a Box.

You may need to call this method before being able to sip.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, Output, Progress> Sipper<Output, Progress> for T

where T: Core<Output = Output, Progress = Progress>,