[][src]Crate signals

The Signals crate is an asynchronous functional-reactive-like api.


Add this to cargo.toml

signals = "*"

Add this to your crate

extern crate signals; 

Simple Example

use signals::{Signal, Emitter, AmEmitter};

fn main() {
    // create a signal that will assert when emitted
    let signal = Signal::new_arc_mutex( |x: u32| Ok(x) );
    let listener = Signal::new_arc_mutex( |x: u32| { assert_ne!(x, 5); Ok(()) } ); //fail!
    // when signal is emitted, listener should execute.

    // emit signal

Complex Example

use signals::{Signal, Emitter};

fn main() {
    // create a bunch of signals. At the last signal, we should fail. 
    // If we do not fail, the signals did not work.
    let root = Signal::new_arc_mutex( |x: u32| Ok(x.to_string()) ); //convert x to string.
    let peek = Signal::new_arc_mutex( |x: String| { println!("Peek: {}", x); Ok(()) } );
    let to_i32 = Signal::new_arc_mutex( |x: String| Ok(x.parse::<i32>()?) ); //convert to integer
    let inc = Signal::new_arc_mutex( |x: i32| Ok(x+1) ); //increment value
    let fail = Signal::new_arc_mutex( |x: i32| { assert_ne!(x, 8); Ok(()) } ); //fail!
    //connect all signals together.
    root.lock().register_listener(&peek); // snoop on the value! - because we can!
    root.lock().register_listener(&to_i32); // parse the string to an integer
    to_i32.lock().register_listener(&inc); //increment the value
    inc.lock().register_listener(&fail); //then finally fail if the value is 8!
    root.lock().emit(7); //7 will increment to 8 and fail!



Signals are the bread and butter of the crate. A signal can trigger other signals whose input is the same output as the original signal. Signals support both threaded and non-threaded children.



This is a polymorphic trait allowing multiple generic signals to be stored in a list.


When creating a Signal, This trait represents the closure Fn allowed.

Type Definitions