algoroutine 0.1.2

Light-weight algebraic effect(algebraic goroutine) in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# algoroutine
Light-weight *algebraic effect* (algebraic goroutine) in Rust.

Using `go!` macro just as Haskell's do notation while we use algebraic effects
instead of monads to avoid monad's composition issue.
Only *one-shot (linear) algebraic effect* based on coroutine is supported.
Therefore we need nightly compiler to transform code.

## Main macros and combinators
- `go!` macro to run effects and coroutines, just like `?` and `.await`.
- `Coroutine.map` to map results.
- `Coroutine.and_then` to chain operations.

## Example
```rust
let prepare = #[coroutine] |_: Option<i32>| {
    go!(Log("preparing".into()) => Effect);
    return ResultCode(0);
};

let logic = #[coroutine] |_: Option<i32>| {
    go!(Log("start".into()) => Effect); // inject Log into Effect type

    go!(State::Set(Some(9)));
    let s = go!(State::Get);
    go!(Log(format!("Got {:?}", s)));

    let res = go!(prepare, None);
    if !res.is_ok() {
        go!(Log(format!("error code: {}", res.0)));
    }
    return res;
};

// Now we can use different ways to interpret `Log` and `State` effects!
let mut handler: Handler<Option<i32>> = Handler::new();
let ans = handler.handle(None, logic);
dbg!(ans);
```
To inject effects, we don't use `coproduct`, just `From`!
See [examples/logging_and_states](./examples/logging_and_state.rs) for details.

## Fun facts
- `goroutine` and `go` syntax is cool (but golang's type system is terrible)
- `algebraic effect` is cool
- `algebraic goroutine (algoroutine)` is probably bad ;)