netidx-bscript 0.28.2

An incremental scripting language for netidx
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

use super::Type;
use crate::{env::Env, Ctx, UserEvent};
use fxhash::FxHashSet;
use netidx::publisher::Value;
use netidx_netproto::value::NakedValue;
use std::{cell::RefCell, collections::HashSet, fmt};

/// A value with it's type, used for formatting
pub struct TVal<'a, C: Ctx, E: UserEvent> {
    pub env: &'a Env<C, E>,
    pub typ: &'a Type,
    pub v: &'a Value,
}

impl<'a, C: Ctx, E: UserEvent> TVal<'a, C, E> {
    fn fmt_int(
        &self,
        f: &mut fmt::Formatter<'_>,
        hist: &mut FxHashSet<(usize, usize)>,
    ) -> fmt::Result {
        if !self.typ.is_a(&self.env, &self.v) {
            return write!(
                f,
                "error, type {} does not match value {}",
                self.typ,
                NakedValue(self.v)
            );
        }
        match (&self.typ, &self.v) {
            (Type::Primitive(_) | Type::Bottom | Type::Fn(_), v) => {
                write!(f, "{}", NakedValue(v))
            }
            (Type::Ref { .. }, v) => match self.typ.lookup_ref(&self.env) {
                Err(e) => write!(f, "error, {e:?}"),
                Ok(typ) => {
                    let typ_addr = (typ as *const Type).addr();
                    let v_addr = (self.v as *const Value).addr();
                    if !hist.contains(&(typ_addr, v_addr)) {
                        hist.insert((typ_addr, v_addr));
                        Self { typ, env: self.env, v }.fmt_int(f, hist)?
                    }
                    Ok(())
                }
            },
            (Type::Array(et), Value::Array(a)) => {
                write!(f, "[")?;
                for (i, v) in a.iter().enumerate() {
                    Self { typ: et, env: self.env, v }.fmt_int(f, hist)?;
                    if i < a.len() - 1 {
                        write!(f, ", ")?
                    }
                }
                write!(f, "]")
            }
            (Type::Array(_), v) => write!(f, "{}", NakedValue(v)),
            (Type::ByRef(_), v) => write!(f, "{}", NakedValue(v)),
            (Type::Struct(flds), Value::Array(a)) => {
                write!(f, "{{")?;
                for (i, ((n, et), v)) in flds.iter().zip(a.iter()).enumerate() {
                    write!(f, "{n}: ")?;
                    match v {
                        Value::Array(a) if a.len() == 2 => {
                            Self { typ: et, env: self.env, v: &a[1] }.fmt_int(f, hist)?
                        }
                        _ => write!(f, "err")?,
                    }
                    if i < flds.len() - 1 {
                        write!(f, ", ")?
                    }
                }
                write!(f, "}}")
            }
            (Type::Struct(_), v) => write!(f, "{}", NakedValue(v)),
            (Type::Tuple(flds), Value::Array(a)) => {
                write!(f, "(")?;
                for (i, (t, v)) in flds.iter().zip(a.iter()).enumerate() {
                    Self { typ: t, env: self.env, v }.fmt_int(f, hist)?;
                    if i < flds.len() - 1 {
                        write!(f, ", ")?
                    }
                }
                write!(f, ")")
            }
            (Type::Tuple(_), v) => write!(f, "{}", NakedValue(v)),
            (Type::TVar(tv), v) => match &*tv.read().typ.read() {
                None => write!(f, "{}", NakedValue(v)),
                Some(typ) => TVal { env: self.env, typ, v }.fmt_int(f, hist),
            },
            (Type::Variant(n, flds), Value::Array(a)) if a.len() >= 2 => {
                write!(f, "`{n}(")?;
                for (i, (t, v)) in flds.iter().zip(a[1..].iter()).enumerate() {
                    Self { typ: t, env: self.env, v }.fmt_int(f, hist)?;
                    if i < flds.len() - 1 {
                        write!(f, ", ")?
                    }
                }
                write!(f, ")")
            }
            (Type::Variant(_, _), Value::String(s)) => write!(f, "`{s}"),
            (Type::Variant(_, _), v) => write!(f, "{}", NakedValue(v)),
            (Type::Set(ts), v) => match ts.iter().find(|t| t.is_a(&self.env, v)) {
                None => write!(f, "{}", NakedValue(v)),
                Some(t) => Self { typ: t, env: self.env, v }.fmt_int(f, hist),
            },
        }
    }
}

impl<'a, C: Ctx, E: UserEvent> fmt::Display for TVal<'a, C, E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        thread_local! {
            static HIST: RefCell<FxHashSet<(usize, usize)>> = RefCell::new(HashSet::default());
        }
        HIST.with_borrow_mut(|hist| self.fmt_int(f, hist))
    }
}