entoli 0.1.2

A functional programming library inspired by haskell.
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::net::TcpStream;
use std::sync::{Arc, Mutex};

use tungstenite::stream::MaybeTlsStream;
use tungstenite::WebSocket;
use tungstenite::{connect, Message};
use url::Url;

use crate::prelude::Io;

type Ws = Arc<Mutex<WebSocket<MaybeTlsStream<TcpStream>>>>;

pub struct WsRun<F> {
    pub url: Url,
    pub f: F,
}

impl<I, F> Io for WsRun<F>
where
    I: Io<Output = ()>,
    F: FnMut(Ws) -> I,
{
    type Output = ();

    fn run(mut self) -> Self::Output {
        let socket = Arc::new(Mutex::new(
            connect(self.url.clone()).expect("Failed to connect").0,
        ));
        (self.f)(socket).run();
    }
}

pub fn ws_run<F>(url: Url, f: F) -> WsRun<F> {
    WsRun { url, f }
}

pub struct WsSend {
    pub socket: Ws,
    pub message: Message,
}

impl Io for WsSend {
    type Output = ();

    fn run(self) -> Self::Output {
        self.socket
            .lock()
            .unwrap()
            .write_message(self.message)
            .unwrap();
    }
}

pub fn ws_send(socket: Ws, message: Message) -> WsSend {
    WsSend { socket, message }
}

pub struct WsRecv {
    pub socket: Ws,
}

impl Io for WsRecv {
    type Output = Message;

    fn run(self) -> Self::Output {
        self.socket.lock().unwrap().read_message().unwrap()
    }
}

pub fn ws_recv(socket: Ws) -> WsRecv {
    WsRecv { socket }
}

pub struct WsClose {
    pub socket: Ws,
}

impl Io for WsClose {
    type Output = ();

    fn run(self) -> Self::Output {
        self.socket.lock().unwrap().close(None).unwrap();
    }
}

pub fn ws_close(socket: Ws) -> WsClose {
    WsClose { socket }
}