Trait Stream 

pub trait Stream<T>:
    Node
    + StreamPeek<T>
    + AsNode { }

A Node which has some state that can peeked at.

Trait Implementations

impl<T> Debug for dyn Stream<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> NodeOperators for dyn Stream<T>

fn count(self: &Rc<Self>) -> Rc<dyn Stream<u64>>

Running count of the number of times it’s source ticks.

fn ticked_at(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>>

Emits the time of source ticks in nanos from unix epoch.

fn ticked_at_elapsed(self: &Rc<Self>) -> Rc<dyn Stream<NanoTime>>

Emits the time of source ticks relative to the start.

fn produce<OUT: Element>( self: &Rc<Self>, func: impl Fn() -> OUT + 'static, ) -> Rc<dyn Stream<OUT>>

Emits the result of supplied closure on each upstream tick.

fn run(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Result<()>

Shortcut for Graph::run i.e. initialise and execute the graph.

fn into_graph(self: &Rc<Self>, run_mode: RunMode, run_for: RunFor) -> Graph

impl<T> StreamOperators<T> for dyn Stream<T>

where T: Element + 'static,

fn accumulate(self: &Rc<Self>) -> Rc<dyn Stream<Vec<T>>>

accumulate the source into a vector

fn average(self: &Rc<Self>) -> Rc<dyn Stream<f64>>

where T: ToPrimitive,

running average of source

fn buffer(self: &Rc<Self>, capacity: usize) -> Rc<dyn Stream<Vec<T>>>

Buffer the source stream. The buffer is automatically flushed on the last cycle;

fn collect(self: &Rc<Self>) -> Rc<dyn Stream<Vec<ValueAt<T>>>>

Used to accumulate values, which can be retrieved after the graph has completed running. Useful for unit tests.

fn collapse<OUT>(self: &Rc<Self>) -> Rc<dyn Stream<OUT>>

where T: IntoIterator<Item = OUT>, OUT: Element,

collapses a burst (i.e. IntoIter[T]) of ticks into a single tick [T].
Does not tick if burst is empty.

fn consume_async<FUT>( self: &Rc<Self>, func: Box<dyn FnOnce(Pin<Box<dyn FutStream<T>>>) -> FUT + Send>, ) -> Rc<dyn Node>

where T: Element + Send, FUT: Future<Output = ()> + Send + 'static,

fn demux<K, F>( self: &Rc<Self>, capacity: usize, func: F, ) -> (Vec<Rc<dyn Stream<T>>>, Overflow<T>)

where T: Element, K: Hash + Eq + PartialEq + Debug + 'static, F: Fn(&T) -> (K, DemuxEvent) + 'static,

Demuxes its source into a Vec of n streams.

fn demux_it<K, F, U>( self: &Rc<Self>, capacity: usize, func: F, ) -> (Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>, Overflow<TinyVec<[U; 1]>>)

where T: IntoIterator<Item = U>, U: Element, K: Hash + Eq + PartialEq + Debug + 'static, F: Fn(&U) -> (K, DemuxEvent) + 'static,

Demuxes its source into a vec of n streams, where source is IntoIterator For example demuxes Vec of U into n streams of Vec of U

fn demux_it_with_map<K, F, U>( self: &Rc<Self>, map: DemuxMap<K>, func: F, ) -> (Vec<Rc<dyn Stream<TinyVec<[U; 1]>>>>, Overflow<TinyVec<[U; 1]>>)

where T: IntoIterator<Item = U>, U: Element, K: Hash + Eq + PartialEq + Debug + 'static, F: Fn(&U) -> (K, DemuxEvent) + 'static,

Demuxes its source into a vec of n streams, where source is IntoIterator For example demuxes Vec of U into n streams of Vec of U

fn for_each( self: &Rc<Self>, func: impl Fn(T, NanoTime) + 'static, ) -> Rc<dyn Node>

executes supplied closure on each tick

fn delay(self: &Rc<Self>, duration: Duration) -> Rc<dyn Stream<T>>

where T: Hash + Eq,

Propagates it’s source, delayed by the specified duration

fn difference(self: &Rc<Self>) -> Rc<dyn Stream<T>>

where T: Sub<Output = T>,

difference in it’s source from one cycle to the next

fn distinct(self: &Rc<Self>) -> Rc<dyn Stream<T>>

where T: PartialEq,

only propagates it’s source if it is changed

fn filter(self: &Rc<Self>, condition: Rc<dyn Stream<bool>>) -> Rc<dyn Stream<T>>

drops source contingent on supplied stream

fn filter_value( self: &Rc<Self>, predicate: impl Fn(&T) -> bool + 'static, ) -> Rc<dyn Stream<T>>

drops source contingent on supplied predicate

fn finally<F: FnOnce(T, &GraphState) + Clone + 'static>( self: &Rc<Self>, func: F, ) -> Rc<dyn Node>

fn fold<OUT: Element>( self: &Rc<Self>, func: impl Fn(&mut OUT, T) + 'static, ) -> Rc<dyn Stream<OUT>>

fn limit(self: &Rc<Self>, limit: u32) -> Rc<dyn Stream<T>>

propagates source up to limit times

fn logged(self: &Rc<Self>, label: &str, level: Level) -> Rc<dyn Stream<T>>

logs source and propagates it

fn map<OUT: Element>( self: &Rc<Self>, func: impl Fn(T) -> OUT + 'static, ) -> Rc<dyn Stream<OUT>>

Map’s it’s source into a new Stream using the supplied closure.

fn mapper<FUNC, OUT>( self: &Rc<Self>, func: FUNC, ) -> Rc<dyn Stream<TinyVec<[OUT; 1]>>>

where T: Element + Send, OUT: Element + Send + Hash + Eq, FUNC: FnOnce(Rc<dyn Stream<TinyVec<[T; 1]>>>) -> Rc<dyn Stream<OUT>> + Send + 'static,

Uses func to build graph, which is spawned on worker thread

fn not(self: &Rc<Self>) -> Rc<dyn Stream<T>>

where T: Not<Output = T>,

negates it’s input

fn print(self: &Rc<Self>) -> Rc<dyn Stream<T>>

fn reduce( self: &Rc<Self>, func: impl Fn(T, T) -> T + 'static, ) -> Rc<dyn Stream<T>>

fn sample(self: &Rc<Self>, trigger: Rc<dyn Node>) -> Rc<dyn Stream<T>>

samples it’s source on each tick of trigger

fn sum(self: &Rc<Self>) -> Rc<dyn Stream<T>>

where T: Add<T, Output = T>,

Implementations on Foreign Types

impl<STREAM, T> Stream<T> for RefCell<STREAM>

where STREAM: StreamPeekRef<T> + 'static, T: Clone + 'static,

Implementors