Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/TeaEntityLab/fpRust

Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust
https://github.com/TeaEntityLab/fpRust

actor-model async coroutine coroutine-library coroutines functional-programming functional-reactive-programming generator handler monad monads optional optional-implementations publisher-subscriber publisher-subscriber-pattern pubsub reactive reactive-programming rust rust-library

Last synced: about 2 months ago
JSON representation

Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust

Awesome Lists containing this project

README 

        
# fpRust



[![tag](https://img.shields.io/github/tag/TeaEntityLab/fpRust.svg)](https://github.com/TeaEntityLab/fpRust)

[![Crates.io](https://img.shields.io/crates/d/fp_rust.svg)](https://crates.io/crates/fp_rust)

[![Travis CI Build Status](https://api.travis-ci.org/TeaEntityLab/fpRust.svg?branch=master)](https://travis-ci.org/TeaEntityLab/fpRust)

[![docs](https://img.shields.io/badge/docs-online-5023dd.svg)](https://docs.rs/fp_rust/)



[![license](https://img.shields.io/github/license/TeaEntityLab/fpRust.svg?style=social&label=License)](https://github.com/TeaEntityLab/fpRust)

[![stars](https://img.shields.io/github/stars/TeaEntityLab/fpRust.svg?style=social&label=Stars)](https://github.com/TeaEntityLab/fpRust)

[![forks](https://img.shields.io/github/forks/TeaEntityLab/fpRust.svg?style=social&label=Fork)](https://github.com/TeaEntityLab/fpRust)



Monad, Functional Programming features for Rust



# Why



I love functional programming, Rx-style coding.



However it's hard to implement them in Rust, and there're few libraries to achieve parts of them.



Thus I implemented fpRust. I hope you would like it :)



# Features



* MonadIO, Rx-like (*`fp_rust::monadio::MonadIO`*)

  * map/fmap/subscribe

  * async/sync

  * Support *`Future`* (*`to_future()`*) with *`feature: for_futures`



* Publisher (*`fp_rust::publisher::Publisher`*)

  * Support *`Stream`* implementation(*`subscribe_as_stream()`*) with *`feature: for_futures`



* Fp functions (*`fp_rust::fp`*)

  * compose!(), pipe!()

  * map!(), reduce!(), filter!(), foldl!(), foldr!()

  * contains!(), reverse!()



* Async (*`fp_rust::sync`* & *`fp_rust::handler::HandlerThread`*)

  * simple BlockingQueue (inspired by *`Java BlockingQueue`*, implemented by built-in *`std::sync::mpsc::channel`*)

  * HandlerThread (inspired by *`Android Handler`*, implemented by built-in *`std::thread`*)

  * WillAsync (inspired by *`Java Future`*)

    * Support as a *`Future`* with *`feature: for_futures`

  * CountDownLatch (inspired by *`Java CountDownLatch`*, implemented by built-in *`std::sync::Mutex`*)

    * Support as a *`Future`* with *`feature: for_futures`



* Cor (*`fp_rust::cor::Cor`*)

  * PythonicGenerator-like Coroutine

  * yield/yieldFrom

  * async/sync



* Actor (*`fp_rust::actor::ActorAsync`*)

  * Pure simple *`Actor`* model(`receive`/`send`/`spawn`)

  * `Context` for keeping internal states

  * Able to communicate with Parent/Children Actors



* DoNotation (*`fp_rust::cor::Cor`*)

  * Haskell DoNotation-like, *macro*



~~* Pattern matching~~



# Usage



## MonadIO (RxObserver-like)



Example:

```rust



extern crate fp_rust;



use std::{

    thread,

    time,

    sync::{

        Arc,

        Mutex,

        Condvar,

    }

};



use fp_rust::handler::{

    Handler,

    HandlerThread,

};

use fp_rust::common::SubscriptionFunc;

use fp_rust::monadio::{

    MonadIO,

    of,

};

use fp_rust::sync::CountDownLatch;



// fmap & map (sync)

let mut _subscription = Arc::new(SubscriptionFunc::new(move |x: Arc| {

    println!("monadio_sync {:?}", x); // monadio_sync 36

    assert_eq!(36, *Arc::make_mut(&mut x.clone()));

}));

let subscription = _subscription.clone();

let monadio_sync = MonadIO::just(1)

    .fmap(|x| MonadIO::new(move || x * 4))

    .map(|x| x * 3)

    .map(|x| x * 3);

monadio_sync.subscribe(subscription);



// fmap & map (async)

let mut _handler_observe_on = HandlerThread::new_with_mutex();

let mut _handler_subscribe_on = HandlerThread::new_with_mutex();

let monadio_async = MonadIO::new_with_handlers(

    || {

        println!("In string");

        String::from("ok")

    },

    Some(_handler_observe_on.clone()),

    Some(_handler_subscribe_on.clone()),

);



let latch = CountDownLatch::new(1);

let latch2 = latch.clone();



thread::sleep(time::Duration::from_millis(1));



let subscription = Arc::new(SubscriptionFunc::new(move |x: Arc| {

    println!("monadio_async {:?}", x); // monadio_async ok



    latch2.countdown(); // Unlock here

}));

monadio_async.subscribe(subscription);

monadio_async.subscribe(Arc::new(SubscriptionFunc::new(move |x: Arc| {

    println!("monadio_async sub2 {:?}", x); // monadio_async sub2 ok

})));

{

    let mut handler_observe_on = _handler_observe_on.lock().unwrap();

    let mut handler_subscribe_on = _handler_subscribe_on.lock().unwrap();



    println!("hh2");

    handler_observe_on.start();

    handler_subscribe_on.start();

    println!("hh2 running");



    handler_observe_on.post(RawFunc::new(move || {}));

    handler_observe_on.post(RawFunc::new(move || {}));

    handler_observe_on.post(RawFunc::new(move || {}));

    handler_observe_on.post(RawFunc::new(move || {}));

    handler_observe_on.post(RawFunc::new(move || {}));

}

thread::sleep(time::Duration::from_millis(1));



// Waiting for being unlcoked

latch.clone().wait();

```



## Publisher (PubSub-like)



Example:

```rust



extern crate fp_rust;



use fp_rust::common::{SubscriptionFunc, RawFunc};

use fp_rust::handler::{Handler, HandlerThread};

use fp_rust::publisher::Publisher;

use std::sync::Arc;



use fp_rust::sync::CountDownLatch;



let mut pub1 = Publisher::new();

pub1.subscribe_fn(|x: Arc| {

    println!("pub1 {:?}", x);

    assert_eq!(9, *Arc::make_mut(&mut x.clone()));

});

pub1.publish(9);



let mut _h = HandlerThread::new_with_mutex();



let mut pub2 = Publisher::new_with_handlers(Some(_h.clone()));



let latch = CountDownLatch::new(1);

let latch2 = latch.clone();



let s = Arc::new(SubscriptionFunc::new(move |x: Arc| {

    println!("pub2-s1 I got {:?}", x);



    latch2.countdown();

}));

pub2.subscribe(s.clone());

pub2.map(move |x: Arc| {

    println!("pub2-s2 I got {:?}", x);

});



{

    let h = &mut _h.lock().unwrap();



    println!("hh2");

    h.start();

    println!("hh2 running");



    h.post(RawFunc::new(move || {}));

    h.post(RawFunc::new(move || {}));

    h.post(RawFunc::new(move || {}));

    h.post(RawFunc::new(move || {}));

    h.post(RawFunc::new(move || {}));

}



pub2.publish(String::from("OKOK"));

pub2.publish(String::from("OKOK2"));



pub2.unsubscribe(s.clone());



pub2.publish(String::from("OKOK3"));



latch.clone().wait();

```



## Cor (PythonicGenerator-like)



Example:

```rust



#[macro_use]

extern crate fp_rust;



use std::time;

use std::thread;



use fp_rust::cor::Cor;



println!("test_cor_new");



let _cor1 = cor_newmutex!(

    |this| {

        println!("cor1 started");



        let s = cor_yield!(this, Some(String::from("given_to_outside")));

        println!("cor1 {:?}", s);

    },

    String,

    i16

);

let cor1 = _cor1.clone();



let _cor2 = cor_newmutex!(

    move |this| {

        println!("cor2 started");



        println!("cor2 yield_from before");



        let s = cor_yield_from!(this, cor1, Some(3));

        println!("cor2 {:?}", s);

    },

    i16,

    i16

);



{

    let cor1 = _cor1.clone();

    cor1.lock().unwrap().set_async(true); // NOTE Cor default async

                                          // NOTE cor1 should keep async to avoid deadlock waiting.(waiting for each other)

}

{

    let cor2 = _cor2.clone();

    cor2.lock().unwrap().set_async(false);

    // NOTE cor2 is the entry point, so it could be sync without any deadlock.

}

cor_start!(_cor1);

cor_start!(_cor2);



thread::sleep(time::Duration::from_millis(1));

```



## Do Notation (Haskell DoNotation-like)



Example:

```rust



#[macro_use]

extern crate fp_rust;



use std::time;

use std::thread;



use fp_rust::cor::Cor;



let v = Arc::new(Mutex::new(String::from("")));



let _v = v.clone();

do_m!(move |this| {

    println!("test_cor_do_m started");



    let cor_inner1 = cor_newmutex_and_start!(

        |this| {

            let s = cor_yield!(this, Some(String::from("1")));

            println!("cor_inner1 {:?}", s);

        },

        String,

        i16

    );

    let cor_inner2 = cor_newmutex_and_start!(

        |this| {

            let s = cor_yield!(this, Some(String::from("2")));

            println!("cor_inner2 {:?}", s);

        },

        String,

        i16

    );

    let cor_inner3 = cor_newmutex_and_start!(

        |this| {

            let s = cor_yield!(this, Some(String::from("3")));

            println!("cor_inner3 {:?}", s);

        },

        String,

        i16

    );



    {

        (*_v.lock().unwrap()) = [

            cor_yield_from!(this, cor_inner1, Some(1)).unwrap(),

            cor_yield_from!(this, cor_inner2, Some(2)).unwrap(),

            cor_yield_from!(this, cor_inner3, Some(3)).unwrap(),

        ].join("");

    }

});



let _v = v.clone();



{

    assert_eq!("123", *_v.lock().unwrap());

}

```



## Fp Functions (Compose, Pipe, Map, Reduce, Filter)



Example:



```rust

#[macro_use]

extern crate fp_rust



use fp_rust::fp::{

  compose_two,

  map, reduce, filter,

};



let add = |x| x + 2;

let multiply = |x| x * 3;

let divide = |x| x / 2;



let result = (compose!(add, multiply, divide))(10);

assert_eq!(17, result);

println!("Composed FnOnce Result is {}", result);



let result = (pipe!(add, multiply, divide))(10);

assert_eq!(18, result);

println!("Piped FnOnce Result is {}", result);



let result = (compose!(reduce!(|a, b| a * b), filter!(|x| *x < 6), map!(|x| x * 2)))(vec![1, 2, 3, 4]);

assert_eq!(Some(8), result);

println!("test_map_reduce_filter Result is {:?}", result);

```



## Actor



### Actor common(send/receive/spawn/states)



Example:



```rust

use std::time::Duration;



use fp_rust::common::LinkedListAsync;



#[derive(Clone, Debug)]

enum Value {

    // Str(String),

    Int(i32),

    VecStr(Vec),

    Spawn,

    Shutdown,

}



let result_i32 = LinkedListAsync::::new();

let result_i32_thread = result_i32.clone();

let result_string = LinkedListAsync::>::new();

let result_string_thread = result_string.clone();

let mut root = ActorAsync::new(

    move |this: &mut ActorAsync<_, _>, msg: Value, context: &mut HashMap| {

        match msg {

            Value::Spawn => {

                println!("Actor Spawn");

                let result_i32_thread = result_i32_thread.clone();

                let spawned = this.spawn_with_handle(Box::new(

                    move |this: &mut ActorAsync<_, _>, msg: Value, _| {

                        match msg {

                            Value::Int(v) => {

                                println!("Actor Child Int");

                                result_i32_thread.push_back(v * 10);

                            }

                            Value::Shutdown => {

                                println!("Actor Child Shutdown");

                                this.stop();

                            }

                            _ => {}

                        };

                    },

                ));

                let list = context.get("children_ids").cloned();

                let mut list = match list {

                    Some(Value::VecStr(list)) => list,

                    _ => Vec::new(),

                };

                list.push(spawned.get_id());

                context.insert("children_ids".into(), Value::VecStr(list));

            }

            Value::Shutdown => {

                println!("Actor Shutdown");

                if let Some(Value::VecStr(ids)) = context.get("children_ids") {

                    result_string_thread.push_back(ids.clone());

                }



                this.for_each_child(move |id, handle| {

                    println!("Actor Shutdown id {:?}", id);

                    handle.send(Value::Shutdown);

                });

                this.stop();

            }

            Value::Int(v) => {

                println!("Actor Int");

                if let Some(Value::VecStr(ids)) = context.get("children_ids") {

                    for id in ids {

                        println!("Actor Int id {:?}", id);

                        if let Some(mut handle) = this.get_handle_child(id) {

                            handle.send(Value::Int(v));

                        }

                    }

                }

            }

            _ => {}

        }

    },

);



let mut root_handle = root.get_handle();

root.start();



// One child

root_handle.send(Value::Spawn);

root_handle.send(Value::Int(10));

// Two children

root_handle.send(Value::Spawn);

root_handle.send(Value::Int(20));

// Three children

root_handle.send(Value::Spawn);

root_handle.send(Value::Int(30));



// Send Shutdown

root_handle.send(Value::Shutdown);



thread::sleep(Duration::from_millis(1));

// 3 children Actors

assert_eq!(3, result_string.pop_front().unwrap().len());



let mut v = Vec::>::new();

for _ in 1..7 {

    let i = result_i32.pop_front();

    println!("Actor {:?}", i);

    v.push(i);

}

v.sort();

assert_eq!(

    [

        Some(100),

        Some(200),

        Some(200),

        Some(300),

        Some(300),

        Some(300)

    ],

    v.as_slice()

)

```



### Actor Ask (inspired by Akka/Erlang)



Example:



```rust

use std::time::Duration;



use fp_rust::common::LinkedListAsync;



#[derive(Clone, Debug)]

enum Value {

    AskIntByLinkedListAsync((i32, LinkedListAsync)),

    AskIntByBlockingQueue((i32, BlockingQueue)),

}



let mut root = ActorAsync::new(

    move |_: &mut ActorAsync<_, _>, msg: Value, _: &mut HashMap| match msg {

        Value::AskIntByLinkedListAsync(v) => {

            println!("Actor AskIntByLinkedListAsync");

            v.1.push_back(v.0 * 10);

        }

        Value::AskIntByBlockingQueue(mut v) => {

            println!("Actor AskIntByBlockingQueue");



            // NOTE If negative, hanging for testing timeout

            if v.0 < 0 {

                return;

            }



            // NOTE General Cases

            v.1.offer(v.0 * 10);

        } // _ => {}

    },

);



let mut root_handle = root.get_handle();

root.start();



// LinkedListAsync

let result_i32 = LinkedListAsync::::new();

root_handle.send(Value::AskIntByLinkedListAsync((1, result_i32.clone())));

root_handle.send(Value::AskIntByLinkedListAsync((2, result_i32.clone())));

root_handle.send(Value::AskIntByLinkedListAsync((3, result_i32.clone())));

thread::sleep(Duration::from_millis(1));

let i = result_i32.pop_front();

assert_eq!(Some(10), i);

let i = result_i32.pop_front();

assert_eq!(Some(20), i);

let i = result_i32.pop_front();

assert_eq!(Some(30), i);



// BlockingQueue

let mut result_i32 = BlockingQueue::::new();

result_i32.timeout = Some(Duration::from_millis(1));

root_handle.send(Value::AskIntByBlockingQueue((4, result_i32.clone())));

root_handle.send(Value::AskIntByBlockingQueue((5, result_i32.clone())));

root_handle.send(Value::AskIntByBlockingQueue((6, result_i32.clone())));

thread::sleep(Duration::from_millis(1));

let i = result_i32.take();

assert_eq!(Some(40), i);

let i = result_i32.take();

assert_eq!(Some(50), i);

let i = result_i32.take();

assert_eq!(Some(60), i);



// Timeout case:

root_handle.send(Value::AskIntByBlockingQueue((-1, result_i32.clone())));

let i = result_i32.take();

assert_eq!(None, i);

```