Struct frappe::Stream

pub struct Stream<T: Clone> { /* fields omitted */ }

A stream of discrete events sent over time.

All the streams returned by the methods below contain an internal reference to it's parent, so dropping intermediate streams won't break the chain.

Methods

impl<T: Clone + 'static> Stream<T>

fn map<F, R>(&self, f: F) -> Stream<R> where
    F: Fn(Cow<T>) -> R + 'static,
    R: Clone + 'static, 

Maps this stream into another stream using the provided function.

fn filter<F>(&self, pred: F) -> Self where
    F: Fn(&T) -> bool + 'static, 

Creates a new stream that only contains the values where the predicate is true.

fn filter_map<F, R>(&self, f: F) -> Stream<R> where
    F: Fn(Cow<T>) -> Option<R> + 'static,
    R: Clone + 'static, 

Filter and map a stream simultaneously.

fn merge(&self, other: &Stream<T>) -> Self

Creates a new stream that fires with the events from both streams.

fn merge_with<U, F, R>(&self, other: &Stream<U>, f: F) -> Stream<R> where
    F: Fn(Either<Cow<T>, Cow<U>>) -> R + 'static,
    U: Clone + 'static,
    R: Clone + 'static, 

Merges two streams of different types using the provided function.

fn inspect<F>(self, f: F) -> Self where
    F: Fn(Cow<T>) + 'static, 

Reads the values without modifying them.

This is meant to be used as a debugging tool and not to cause side effects.

fn channel(&self) -> Receiver<T>

Creates a channel and sends the stream events through it.

fn hold(&self, initial: T) -> SignalShared<T>

Creates a Signal that holds the last value sent to this stream.

fn hold_if<F>(&self, initial: T, pred: F) -> SignalShared<T> where
    F: Fn(&T) -> bool + 'static, 

Holds the last value in this stream where the predicate is true.

fn fold<A, F>(&self, initial: A, f: F) -> SignalShared<A> where
    F: Fn(A, Cow<T>) -> A + 'static,
    A: Clone + 'static, 

Accumulates the values sent over this stream.

fn map_n<F, R>(&self, f: F) -> Stream<R> where
    F: Fn(Cow<T>, Sink<R>) + 'static,
    R: Clone + 'static, 

Maps each stream event to 0..N output values.

The closure must return it's value by sending it through the provided sink. Multiple values (or none) can be sent to the output stream this way.

This primitive is useful to construct asynchronous operations, since you can store the sink for later usage.

impl<T: Clone + 'static> Stream<Option<T>>

fn filter_some(&self) -> Stream<T>

Filters a stream of Option, returning the unwrapped Some values

impl<T: SumType2 + Clone + 'static> Stream<T> where
    T::Type1: Clone + 'static,
    T::Type2: Clone + 'static, 

fn filter_first(&self) -> Stream<T::Type1>

Creates a stream with only the first element of a sum type

fn filter_second(&self) -> Stream<T::Type2>

Creates a stream with only the second element of a sum type

fn split(&self) -> (Stream<T::Type1>, Stream<T::Type2>)

Splits a two element sum type stream into two streams with the unwrapped values

impl<T: Clone + 'static> Stream<Stream<T>>

fn switch(&self) -> Stream<T>

Listens to the events from the last stream sent to a nested stream

Trait Implementations

impl<T: Debug + Clone> Debug for Stream<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Clone + Clone> Clone for Stream<T>

fn clone(&self) -> Stream<T>

Returns a copy of the value.

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

Performs copy-assignment from source.