Struct mogwai::txrx::Receiver

pub struct Receiver<A> { /* fields omitted */ }

Receive messages instantly.

Implementations

impl<A> Receiver<A>

pub fn new() -> Receiver<A>

Create a new Receiver.

pub fn respond<F>(self, f: F) where
    F: FnMut(&A) + 'static, 

Set the response this receiver has to messages. Upon receiving a message the response will run immediately.

pub fn respond_shared<T: 'static, F>(self, val: Rc<RefCell<T>>, f: F) where
    F: Fn(&mut T, &A) + 'static, 

Set the response this receiver has to messages. Upon receiving a message the response will run immediately.

Folds mutably over a Rc<RefCell>.

pub fn drop_responder(&self)

Removes the responder from the receiver. This drops anything owned by the responder.

pub fn new_trns(&self) -> Transmitter<A>

Spawn a new Transmitter that sends to this Receiver.

pub fn branch(&self) -> Receiver<A>

Branch a receiver off of the original. Each branch will receive from the same transmitter. The new branch has no initial response to messages.

pub fn branch_filter_fold<B, X, T, F>(&self, init: X, f: F) -> Receiver<B> where
    B: 'static,
    X: Into<T>,
    T: 'static,
    F: Fn(&mut T, &A) -> Option<B> + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateful fold function.

The fold function returns an Option<B>. In the case that the value of Option<B> is None, no message will be sent to the new receiver.

Each branch will receive from the same transmitter.

pub fn branch_filter_fold_shared<B, T, F>(
    &self,
    state: Rc<RefCell<T>>,
    f: F
) -> Receiver<B> where
    B: 'static,
    T: 'static,
    F: Fn(&mut T, &A) -> Option<B> + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateful fold function, where the state is a shared mutex.

The fold function returns an Option<B>. In the case that the value of Option<B> is None, no message will be sent to the new receiver.

Each branch will receive from the same transmitter.

pub fn branch_fold<B, X, T, F>(&self, init: X, f: F) -> Receiver<B> where
    B: 'static,
    X: Into<T>,
    T: 'static,
    F: Fn(&mut T, &A) -> B + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateful fold function.

All output of the fold function is sent to the new receiver.

Each branch will receive from the same transmitter(s).

pub fn branch_fold_shared<B, T, F>(
    &self,
    t: Rc<RefCell<T>>,
    f: F
) -> Receiver<B> where
    B: 'static,
    T: 'static,
    F: Fn(&mut T, &A) -> B + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateful fold function, where the state is a shared mutex.

All output of the fold function is sent to the new receiver.

Each branch will receive from the same transmitter(s).

pub fn branch_filter_map<B, F>(&self, f: F) -> Receiver<B> where
    B: 'static,
    F: Fn(&A) -> Option<B> + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateless map function.

The map function returns an Option<B>, representing an optional message to send to the new receiver. In the case that the result value of the map function is None, no message will be sent to the new receiver.

Each branch will receive from the same transmitter.

pub fn branch_map<B, F>(&self, f: F) -> Receiver<B> where
    B: 'static,
    F: Fn(&A) -> B + 'static, 

Branch a new receiver off of an original and wire any messages sent to the original by using a stateless map function.

All output of the map function is sent to the new receiver.

Each branch will receive from the same transmitter.

pub fn forward_filter_fold_shared<B, T, F>(
    self,
    tx: &Transmitter<B>,
    var: Rc<RefCell<T>>,
    f: F
) where
    B: 'static,
    T: 'static,
    F: Fn(&mut T, &A) -> Option<B> + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateful fold function, where the state is a shared mutex.

The fold function returns an Option<B>. In the case that the value of Option<B> is None, no message will be sent to the transmitter.

pub fn forward_filter_fold<B, X, T, F>(self, tx: &Transmitter<B>, init: X, f: F) where
    B: 'static,
    T: 'static,
    X: Into<T>,
    F: Fn(&mut T, &A) -> Option<B> + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateful fold function.

The fold function returns an Option<B>. In the case that the value of Option<B> is None, no message will be sent to the transmitter.

pub fn forward_fold<B, X, T, F>(self, tx: &Transmitter<B>, init: X, f: F) where
    B: 'static,
    T: 'static,
    X: Into<T>,
    F: Fn(&mut T, &A) -> B + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateful fold function. All output of the fold function is sent to the given transmitter.

pub fn forward_fold_shared<B, T, F>(
    self,
    tx: &Transmitter<B>,
    t: Rc<RefCell<T>>,
    f: F
) where
    B: 'static,
    T: 'static,
    F: Fn(&mut T, &A) -> B + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateful fold function, where the state is a shared mutex. All output of the fold function is sent to the given transmitter.

pub fn forward_filter_map<B, F>(self, tx: &Transmitter<B>, f: F) where
    B: 'static,
    F: Fn(&A) -> Option<B> + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateless map function. If the map function returns None for any messages those messages will not be sent to the given transmitter.

pub fn forward_map<B, F>(self, tx: &Transmitter<B>, f: F) where
    B: 'static,
    F: Fn(&A) -> B + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateless map function. All output of the map function is sent to the given transmitter.

pub fn forward_filter_fold_async<T, B, X, F, H>(
    self,
    tb: &Transmitter<B>,
    init: X,
    f: F,
    h: H
) where
    B: 'static,
    T: 'static,
    X: Into<T>,
    F: Fn(&mut T, &A) -> Option<RecvFuture<B>> + 'static,
    H: Fn(&mut T, &Option<B>) + 'static, 

Forwards messages on the given receiver to the given transmitter using a stateful fold function that returns an optional future. The future, if returned, is executed. The future results in an Option<B>. In the case that the value of the future's result is None, no message will be sent to the transmitter.

Lastly, a clean up function is ran at the completion of the future with its result.

To aid in returning a viable future in your fold function, use wrap_future.

pub fn merge<B: 'static>(rxs: Vec<Receiver<B>>) -> Receiver<B>

Merge all the receivers into one. Any time a message is received on any receiver, it will be sent to the returned receiver.

pub fn message(&self) -> impl Future<Output = A> where
    A: Clone + 'static, 

Create a future to await the next message received by this Receiver.

Trait Implementations

impl<A> Clone for Receiver<A>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Receiver<String>> for ViewBuilder<Text>

pub fn from(later: Receiver<String>) -> Self

Performs the conversion.

impl<T> From<Receiver<T>> for Effect<T>

pub fn from(later: Receiver<T>) -> Effect<T>

Performs the conversion.