graphix-stdlib 0.3.1

A dataflow language for UIs and network programming, standard library
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

use crate::run;
use anyhow::{bail, Result};
use netidx::subscriber::Value;

const NET_PUB_SUB: &str = r#"
{
  net::publish("/local/foo", 42);
  net::subscribe("/local/foo")?
}
"#;

run!(net_pub_sub, NET_PUB_SUB, |v: Result<&Value>| {
    match v {
        Ok(Value::I64(42)) => true,
        _ => false,
    }
});

const NET_WRITE0: &str = r#"
{
  let p = "/local/foo";
  let x = 42;
  net::publish(#on_write:|v| x <- cast<i64>(v)?, p, x);
  let s = cast<i64>(net::subscribe(p)?)?;
  net::write(p, once(s + 1));
  array::group(s, |n, _| n == 2)
}
"#;

run!(net_write0, NET_WRITE0, |v: Result<&Value>| {
    match v {
        Ok(Value::Array(a)) => match &a[..] {
            [Value::I64(42), Value::I64(43)] => true,
            _ => false,
        },
        _ => false,
    }
});

const NET_WRITE1: &str = r#"
{
  let p = "/local/foo";
  let x = 42;
  net::publish(#on_write:|v: string| x <- cast<i64>(v)?, p, x);
  let s = cast<i64>(net::subscribe(p)?)?;
  net::write(p, once(s + 1));
  array::group(s, |n, _| n == 2)
}
"#;

run!(net_write1, NET_WRITE1, |v: Result<&Value>| {
    match v {
        Ok(_) => false,
        Err(_) => true,
    }
});

const NET_LIST: &str = r#"
{
  net::publish("/local/foo", 42);
  net::publish("/local/bar", 42);
  net::list("/local")
}
"#;

run!(net_list, NET_LIST, |v: Result<&Value>| {
    match v {
        Ok(Value::Array(a)) => match &a[..] {
            [Value::String(s0), Value::String(s1)] => {
                let mut a = [s0, s1];
                a.sort();
                a[0] == "/local/bar" && a[1] == "/local/foo"
            }
            _ => false,
        },
        _ => false,
    }
});

const NET_LIST_TABLE: &str = r#"
{
  net::publish("/local/t/0/foo", 42);
  net::publish("/local/t/0/bar", 42);
  net::publish("/local/t/1/foo", 42);
  net::publish("/local/t/1/bar", 42);
  let t = dbg(net::list_table("/local/t"))?;
  let cols = array::map(t.columns, |(n, _)| n);
  (array::sort(cols) == ["bar", "foo"])
  && (array::sort(t.rows) == ["/local/t/0", "/local/t/1"])
}
"#;

run!(net_list_table, NET_LIST_TABLE, |v: Result<&Value>| {
    match v {
        Ok(Value::Bool(true)) => true,
        _ => false,
    }
});

const NET_RPC0: &str = r#"
{
  let get_val = "/local/get_val";
  let set_val = "/local/set_val";
  let v: Any = never();
  net::rpc(
    #path:get_val,
    #doc:"get the value",
    #spec:[],
    #f:|a| a ~ v);
  net::rpc(
    #path:set_val,
    #doc:"set the value",
    #spec:[{name: "val", doc: "The value", default: null}],
    #f:|args| select cast<{val: Any}>(args) {
        error as e => e,
        { val } => {
          v <- val;
          val ~ null
        }
    });
  net::call(set_val, [("val", 42)]);
  net::call(get_val, [])
}
"#;

run!(net_rpc0, NET_RPC0, |v: Result<&Value>| {
    match v {
        Ok(Value::I64(42)) => true,
        _ => false,
    }
});