Struct carboxyl::SignalMut
[−]
[src]
pub struct SignalMut<A> { // some fields omitted }
Signal variant using inner mutability for efficient in-place updates.
This is the only kind of primitive that allows non-Clone
types to be
wrapped into functional reactive abstractions. The API is somewhat different
from that of a regular signal to accommodate this.
One cannot directly sample a SignalMut
as this would require a clone.
Instead it comes with a couple of adaptor methods that mimick a subset of
the Signal
API. However, all functions passed to these methods take the
argument coming from the SignalMut
by reference.
Methods
impl<A: Send + Sync + 'static> SignalMut<A>
fn snapshot<B, C, F>(&self, stream: &Stream<B>, f: F) -> Stream<C> where B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, F: Fn(&A, B) -> C + Send + Sync + 'static
Semantically the same as Signal::snapshot
The key difference here is, that the combining function takes its first
argument by reference, as it can't be moved out of the SignalMut
.
Example
let sink1 = Sink::new(); let sink2 = Sink::new(); // Collect values in a mutable `Vec` let values = sink1.stream().scan_mut(vec![], |v, a| v.push(a)); // Snapshot some value from it let mut index = values.snapshot(&sink2.stream(), |v, k| v.get(k).map(|x| *x) ).events(); sink1.send(4); sink1.send(5); sink2.send(0); assert_eq!(index.next(), Some(Some(4))); sink2.send(1); assert_eq!(index.next(), Some(Some(5))); sink2.send(2); assert_eq!(index.next(), Some(None));
fn combine<B, C, F>(&self, signal: &Signal<B>, f: F) -> Signal<C> where B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, F: Fn(&A, B) -> C + Send + Sync + 'static
Similar to lift2
. Combines a SignalMut
with a Signal
using a
function. The function takes its first argument by reference.
fn combine_mut<B, C, F>(&self, other: &SignalMut<B>, f: F) -> Signal<C> where B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, F: Fn(&A, &B) -> C + Send + Sync + 'static
Similar to lift2
, but combines two SignalMut
using a function. The
supplied function takes both arguments by reference.
Example
let sink: Sink<i32> = Sink::new(); let sum = sink.stream().scan_mut(0, |sum, a| *sum += a); let product = sink.stream().scan_mut(1, |prod, a| *prod *= a); let combo = sum.combine_mut(&product, |s, p| (*s, *p)); sink.send(1); assert_eq!(combo.sample(), (1, 1)); sink.send(3); assert_eq!(combo.sample(), (4, 3)); sink.send(5); assert_eq!(combo.sample(), (9, 15));