ksl 0.1.30

KSL core library and interpreter
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! # ksl::builtin::channel
//!
//! Built-in math functions about `Receiver` and `Sender`.
//!
//! - OpenChannel
//! - ReceiveValue
//! - DropReceiver
//! - SendValue
//! - DropSender

use crate::{Environment, eval::apply::eval_apply, impl_native_object, is_invalid_symbol, value::Value};

impl_native_object! {
    rust_type: std::sync::mpsc::Receiver<Value>,
    type_name_const: MPSC_RECEIVER_TYPE_NAME,
    type_name_str: "MpscReceiver",
    with_fn: {
        name: with_mpsc_receiver,
        error_prefix: "ksl::builtin::channel"
    },
    drop_fn: {
        name: drop_receiver,
        func_name: "DropReceiver",
        error_prefix: "ksl::builtin::channel"
    }
}

impl_native_object! {
    rust_type: std::sync::mpsc::Sender<Value>,
    type_name_const: MPSC_SENDER_TYPE_NAME,
    type_name_str: "MpscSender",
    with_fn: {
        name: with_mpsc_sender,
        error_prefix: "ksl::builtin::channel"
    },
    drop_fn: {
        name: drop_sender,
        func_name: "DropSender",
        error_prefix: "ksl::builtin::channel"
    }
}

pub(crate) fn open_channel(args: &[Value], env: Environment) -> Result<Value, std::sync::Arc<str>> {
    if let [rx_val, tx_val] = args {
        match (rx_val, tx_val) {
            (Value::Symbol(rx_sym), Value::Symbol(tx_sym)) => {
                if is_invalid_symbol(rx_sym) || is_invalid_symbol(tx_sym) {
                    Err(std::sync::Arc::from(format!(
                        concat!(
                            "Error[ksl::builtin::OpenChannel]: ",
                            "Rebinding of symbol `{}` or `{}` is not permitted."
                        ),
                        rx_sym, tx_sym
                    )))
                } else {
                    let (tx, rx) = std::sync::mpsc::channel::<Value>();

                    let rx_obj = Value::NativeObject(
                        MPSC_RECEIVER_TYPE_NAME.clone(),
                        std::sync::Arc::new(parking_lot::Mutex::new(rx)),
                    );
                    let tx_obj = Value::NativeObject(
                        MPSC_SENDER_TYPE_NAME.clone(),
                        std::sync::Arc::new(parking_lot::Mutex::new(tx)),
                    );

                    env.store
                        .write()
                        .insert(rx_sym.clone(), std::sync::Arc::new(rx_obj));
                    env.store
                        .write()
                        .insert(tx_sym.clone(), std::sync::Arc::new(tx_obj));

                    Ok(Value::Unit)
                }
            }
            (Value::Symbol(_), e) => Err(std::sync::Arc::from(format!(
                "Error[ksl::builtin::OpenChannel]: Sender must be a symbol, got `{}`.",
                e
            ))),
            (e, _) => Err(std::sync::Arc::from(format!(
                "Error[ksl::builtin::OpenChannel]: Receiver must be a symbol, got `{}`.",
                e
            ))),
        }
    } else {
        Err(std::sync::Arc::from(format!(
            "Error[ksl::builtin::OpenChannel]: Expected 2 parameters, but {} were passed.",
            args.len()
        )))
    }
}

pub(crate) fn receive_value(args: &[Value], env: Environment) -> Result<Value, std::sync::Arc<str>> {
    if let [rx_obj] = args {
        let rx_val = eval_apply(rx_obj, env.clone())?;

        with_mpsc_receiver(&rx_val, |rx| match rx.recv() {
            Ok(val) => Ok(val),
            Err(e) => Err(std::sync::Arc::from(format!(
                "Error[ksl::builtin::ReceiveValue]: Failed to receive value with `{}`.",
                e
            ))),
        })
    } else {
        Err(std::sync::Arc::from(format!(
            "Error[ksl::builtin::ReceiveValue]: Expected 1 parameter, but {} were passed.",
            args.len()
        )))
    }
}

pub(crate) fn send_value(args: &[Value], env: Environment) -> Result<Value, std::sync::Arc<str>> {
    if let [tx_obj, val_obj] = args {
        let tx_val = eval_apply(tx_obj, env.clone())?;
        let val = eval_apply(val_obj, env)?;

        with_mpsc_sender(&tx_val, |tx| match tx.send(val) {
            Ok(()) => Ok(Value::Unit),
            Err(e) => Err(std::sync::Arc::from(format!(
                "Error[ksl::builtin::SendValue]: Failed to send value `{}` with `{}`.",
                val_obj, e
            ))),
        })
    } else {
        Err(std::sync::Arc::from(format!(
            "Error[ksl::builtin::SendValue]: Expected 1 parameter, but {} were passed.",
            args.len()
        )))
    }
}