Expand description
The Signals crate is an asynchronous functional-reactive-like api.
Installation
Add this to cargo.toml
[dependencies]
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.
signal.lock().register_listener(&listener);
// emit signal
signal.lock().emit(5);
}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!
}Structs
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.
Traits
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.