Struct cfrp::primitives::fold::FoldSignal

pub struct FoldSignal<F, A, B> where
    F: 'static + Send + Fn(B, A) -> B,
    A: 'static + Send + Clone,
    B: 'static + Send + Clone,  { /* fields omitted */ }

The result of a fold operation

Methods

impl<F, A, B> FoldSignal<F, A, B> where
    F: 'static + Send + Fn(B, A) -> B,
    A: 'static + Send + Clone,
    B: 'static + Send + Clone, 

fn new(config: Config, parent: Box<Signal<A>>, initial: B, f: F) -> Self

Trait Implementations

impl<F, A, B> Signal<B> for FoldSignal<F, A, B> where
    F: 'static + Send + Fn(B, A) -> B,
    A: 'static + Send + Clone,
    B: 'static + Send + Clone, 

fn config(&self) -> Config

fn initial(&self) -> SignalType<B>

fn push_to(self: Box<Self>, target: Option<Box<Push<B>>>)

fn init(&mut self)

impl<F, A, B> SignalExt<B> for FoldSignal<F, A, B> where
    F: 'static + Send + Fn(B, A) -> B,
    A: 'static + Send + Clone,
    B: 'static + Send + Clone, 

fn lift<F, B>(self, f: F) -> LiftSignal<F, A, B> where
    F: 'static + Send + Fn(A) -> B,
    B: 'static + Send + Clone, 

Transform in input signal into an output signal

fn lift2<F, SB, B, C>(self, right: SB, f: F) -> Lift2Signal<F, A, B, C> where
    SB: 'static + Signal<B>,
    F: 'static + Send + Fn(Value<A>, Value<B>) -> C,
    B: 'static + Send + Clone,
    C: 'static + Send + Clone, 

Combine two signals into an output signal

fn fold<F, B>(self, initial: B, f: F) -> FoldSignal<F, A, B> where
    F: 'static + Send + Fn(B, A) -> B,
    B: 'static + Send + Clone, 

Merge data from a signal into an accumulator and return a signal with the accumulator's value

fn add_to(self, builder: &Builder) -> Branch<A>

Sugar for Builder::add

fn async(self, builder: &Builder) -> Branch<A>

Sugar for Builder::async

fn map<F, B>(self, f: F) -> LiftSignal<F, A, B> where
    F: 'static + Send + Fn(A) -> B,
    B: 'static + Send + Clone, 

Alias of lift

fn zip<SB, B>(self, right: SB) -> Box<Signal<(Value<A>, Value<B>)>> where
    SB: 'static + Signal<B>,
    B: 'static + Send + Clone, 

Takes two input signals and returns a signal containing 2-tuples of elements from the input signals.

fn enumerate(self) -> Box<Signal<(usize, A)>>

Same as Iterator::enumerate.

fn filter<F>(self, f: F) -> Box<Signal<Option<A>>> where
    F: 'static + Send + Fn(&A) -> bool, 

Filter an input stream by a predicate function F.

fn inspect<F>(self, f: F) -> Box<Signal<A>> where
    F: 'static + Send + Fn(&A) -> bool, 

Pass each value in a signal to F before sending it to an output signal.