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

use melodium_core::*;
use melodium_macro::{check, mel_function, mel_treatment};

pub mod block;

/// Unwrap option of return default value
#[mel_function(
    generic T ()
)]
pub fn unwrap_or(option: Option<T>, default: T) -> T {
    option.unwrap_or(default)
}

/// Unwrap option stream
///
/// Unwrap every option in stream, ignoring values set to _none_.
#[mel_treatment(
    generic T ()
    input option Stream<Option<T>>
    output value Stream<T>
)]
pub async fn unwrap() {
    while let Ok(values) = option
        .recv_many()
        .await
        .map(|values| Into::<VecDeque<Value>>::into(values))
    {
        check!(
            value
                .send_many(TransmissionValue::Other(
                    values
                        .into_iter()
                        .filter_map(|val| match val {
                            Value::Option(Some(val)) => Some(*val),
                            _ => None,
                        })
                        .collect()
                ))
                .await
        )
    }
}

/// Unwrap option stream with default value
///
/// Unwrap every option in stream, sending `default` value when option is _none_.
#[mel_treatment(
    generic T ()
    input option Stream<Option<T>>
    output value Stream<T>
)]
pub async fn unwrap_or(default: T) {
    while let Ok(values) = option
        .recv_many()
        .await
        .map(|values| Into::<VecDeque<Value>>::into(values))
    {
        check!(
            value
                .send_many(TransmissionValue::Other(
                    values
                        .into_iter()
                        .filter_map(|val| match val {
                            Value::Option(Some(val)) => Some(*val),
                            Value::Option(None) => Some(default.clone()),
                            _ => None,
                        })
                        .collect()
                ))
                .await
        )
    }
}

/// Unwrap option stream until _none_ is present
///
/// Unwrap every option in stream, and stop at the first _none_ value encountered.
#[mel_treatment(
    generic T ()
    input option Stream<Option<T>>
    output value Stream<T>
)]
pub async fn fuse() {
    'main: while let Ok(values) = option
        .recv_many()
        .await
        .map(|values| Into::<VecDeque<Value>>::into(values))
    {
        for val in values {
            match val {
                Value::Option(Some(val)) => check!('main, value.send_one(*val).await),
                _ => break 'main,
            }
        }
    }
}

/// Wrap a value in an option
#[mel_function(
    generic T ()
)]
pub fn wrap(value: T) -> Option<T> {
    Some(value)
}

/// Wrap values in options
///
/// Takes a stream of values and turn them into filled options.
#[mel_treatment(
    generic T ()
    input value Stream<T>
    output option Stream<Option<T>>
)]
pub async fn wrap() {
    while let Ok(values) = value
        .recv_many()
        .await
        .map(|values| Into::<VecDeque<Value>>::into(values))
    {
        check!(
            option
                .send_many(TransmissionValue::Other(
                    values
                        .into_iter()
                        .map(|val| Value::Option(Some(Box::new(val))))
                        .collect()
                ))
                .await
        )
    }
}