Struct Stream

pub struct Stream<'a, Sig> { /* private fields */ }

A stream of signals.

A stream represents a composable signal producer. When you decide to send a signal down a stream, any other streams composed with that first stream will also receive the signal. This enables to construct more interesting and complex streams by composing them via, for instance, Stream::map, Stream::filter_map, Stream::filter, Stream::fold, Stream::merge, Stream::zip, etc.

Implementations

impl<'a, Sig> Stream<'a, Sig>

where Sig: 'a + Send + Sync,

pub fn new() -> Self

Create a new stream.

pub fn observe<F>(&self, subscriber: F) -> u128

where F: 'a + FnMut(&Sig) + Send,

Observe a stream signal output flowing out of the stream.

Do not abuse this function, as its primary use is to build other combinators.

pub fn observe_with_handle<F>(&self, subscriber: F, handle_id: u128)

where F: 'a + FnMut(&Sig) + Send,

Observe a stream signal output flowing out of the stream.

Do not abuse this function, as its primary use is to build other combinators.

pub fn remove(&self, handle_id: u128)

Removes the subscriber with the given handle_id.

pub fn clear(&self)

Removes all subscribers without dropping the stream.

pub fn send(&self, signal: &Sig)

Send a signal down the stream.

pub fn map<F, OutSig>(&self, f: F) -> Stream<'a, OutSig>

where F: 'a + Fn(&Sig) -> OutSig + Send, OutSig: 'a + Send + Sync,

Map any signals flowing out of a stream.

Please note that this function is total: you cannot ignore signals. Even if you map uninteresting signals to None, you’ll still compose signals for those. If you’re interested in filtering signals while mapping, have a look at the Stream::filter_map function.

pub fn filter_map<F, OutSig>(&self, f: F) -> Stream<'a, OutSig>

where F: 'a + Fn(&Sig) -> Option<OutSig> + Send, OutSig: 'a + Send + Sync,

Filter and map signals flowing out of a stream.

If you’re not interested in a specific signal, you can emit None: no signal will be sent.

pub fn filter<F>(&self, pred: F) -> Self

where F: 'a + Fn(&Sig) -> bool + Send,

Filter the signals flowing out of a stream with a predicate.

pub fn fold<F, A>(&self, value: A, f: F) -> Stream<'a, A>

where F: 'a + Fn(A, &Sig) -> A + Send, A: 'a + Send + Sync,

Fold all signals flowing out of a stream into a stream of values.

pub fn merge(&self, rhs: &Self) -> Self

Merge two streams into one.

Merging streams enables you to perform later useful compositions, such as folding the merged results.

pub fn merge_with<F, SigRHS>( &self, rhs: &Stream<'a, SigRHS>, adapter: F, ) -> Self

where F: 'a + Fn(&SigRHS) -> Sig + Send, SigRHS: 'a + Send + Sync,

Merge two streams into one with incompatible types.

This method performs the same logical operation as:

use reactive_graph_reactive_model_impl::Stream;

let stream_a = Stream::new();
let stream_b = Stream::new();
let merged = stream_a.merge(&stream_b.map(String::len));

However, because it does it in a more optimal way, you are advised to use this combinator instead.

pub fn zip<SigRHS>( &self, rhs: &Stream<'a, SigRHS>, ) -> Stream<'a, Either<Sig, SigRHS>>

where Sig: Clone + Send, SigRHS: 'a + Clone + Send + Sync,

Zip two streams with each other.

The resulting stream will output Either from one or the other stream.

pub fn entangled<F, G, GSig>(f: F, g: G) -> (Self, Stream<'a, GSig>)

where F: 'a + Fn(&Sig) -> Option<GSig> + Send, G: 'a + Fn(&GSig) -> Option<Sig> + Send, GSig: 'a + Send + Sync,

Create a pair of entangled streams.

If any of the streams sends a signal, the other one receives it. However, be careful: since the signals are defined in terms of each other, it’s quite easy to cause infinite loops if you don’t have a well-defined bottom to your recursion. This is why you’re expected to return Option<_> signals.

pub fn recv(&self) -> Receiver<Sig>

where Sig: Clone,

Sink a stream.

This method allows to receive the signal and extract it out of the stream via a channel.

impl<'a, SigA, SigB> Stream<'a, Either<SigA, SigB>>

where SigA: 'static + Send + Sync, SigB: 'static + Send + Sync,

pub fn unzip(&self) -> (Stream<'a, SigA>, Stream<'a, SigB>)

Split a stream of zipped values into two streams.

If the Either::Left part of the stream emits a signal, it is sent to the first stream. If the Either::Right part of the tream emits, it is sent to the second stream.

Trait Implementations

impl<'a, Sig> Default for Stream<'a, Sig>

where Sig: 'a + Send + Sync,

fn default() -> Self

Returns the “default value” for a type.

impl<Sig> Send for Stream<'_, Sig>

TODO: This solves many problems, but is it really OK?

impl<Sig> Sync for Stream<'_, Sig>