#signals #frp #emitter


A functional-reactive-like library for Rust that allows asynchronous chaining

3 releases

Uses old Rust 2015

0.0.5 Dec 18, 2018
0.0.2 Oct 27, 2018
0.0.1 Mar 8, 2018

#258 in Asynchronous

26 downloads per month
Used in protocols


141 lines

Build Status License: MIT License


Current version: 0.0.5

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!


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.