async-observable

Examples

Simple Forking

```rust use async_observable::Observable;

[async_std::main]

async fn main() { let mut observable = Observable::new(0); let mut fork = observable.clone();

observable.publish(1);

assert_eq!(fork.wait().await, 1);

} ```

Notifying A Task

```rust use asyncstd::task::{sleep, spawn}; use asyncobservable::Observable;

[async_std::main]

async fn main() { let mut observable = Observable::new(0); let mut fork = observable.clone();

let task = spawn(async move {
    loop {
        let update = fork.next().await;
        println!("task received update {}", update);

        if update >= 3 {
            break;
        }
    }
});

observable.publish(1);
sleep(std::time::Duration::from_millis(100)).await;
observable.publish(2);
sleep(std::time::Duration::from_millis(100)).await;
observable.publish(3);

task.await;

} ```

Execution Control

You may mimic the behavior of a mutex but with an observable you can kick of many asynchronous tasks if the value changes. We'll just use a bool observable, which we publish only once.

```rust use asyncstd::task::{sleep, spawn}; use asyncobservable::Observable; use futures::join;

[async_std::main]

async fn main() { let mut execute = Observable::new(false); let mut executeforkone = execute.clone(); let mut executeforktwo = execute.clone();

let task_one = spawn(async move {
    println!("task one started");
    execute_fork_one.next().await;
    println!("task one ran");
});

let task_two = spawn(async move {
    println!("task two started");
    execute_fork_two.next().await;
    println!("task two ran");
});

join!(
    task_one,
    task_two,
    spawn(async move {
        println!("main task started");

        // run some fancy business logic
        sleep(std::time::Duration::from_millis(100)).await;
        // then release our tasks to do stuff when we are done
        execute.publish(true);

        println!("main task ran");
    })
);

} ```

You could argue and say that you may aswell just spawn the tasks in the moment you want to kick of something - thats true and the better solution if you just want sub tasks. But if you want to notify a completly different part of your program this becomes hard. Or for example if you want to run a task in half, wait for something the other task did and then resume.