graphix_compiler/typ/
tval.rs

1use super::{PrintFlag, Type};
2use crate::{env::Env, typ::format_with_flags};
3use fxhash::FxHashSet;
4use netidx::publisher::Value;
5use netidx_value::NakedValue;
6use poolshark::local::LPooled;
7use std::fmt;
8
9/// A value with it's type, used for formatting
10pub struct TVal<'a> {
11    pub env: &'a Env,
12    pub typ: &'a Type,
13    pub v: &'a Value,
14}
15
16impl<'a> TVal<'a> {
17    fn fmt_int(
18        &self,
19        f: &mut fmt::Formatter<'_>,
20        hist: &mut FxHashSet<(usize, usize)>,
21    ) -> fmt::Result {
22        if !self.typ.is_a(&self.env, &self.v) {
23            return format_with_flags(PrintFlag::DerefTVars, || {
24                eprintln!("error, type {} does not match value {:?}", self.typ, self.v);
25                write!(f, "{}", NakedValue(self.v))
26            });
27        }
28        match (&self.typ, &self.v) {
29            (
30                Type::Primitive(_)
31                | Type::Abstract { .. }
32                | Type::Bottom
33                | Type::Any
34                | Type::Error(_),
35                v,
36            ) => {
37                write!(f, "{}", NakedValue(v))
38            }
39            (Type::Fn(_), Value::Abstract(v)) => write!(f, "{v:?}"),
40            (Type::Fn(_), v) => write!(f, "{}", NakedValue(v)),
41            (Type::Ref { .. }, v) => {
42                let typ = match self.typ.lookup_ref(&self.env) {
43                    Err(e) => return write!(f, "error, {e:?}"),
44                    Ok(typ) => typ,
45                };
46                let typ_addr = (&typ as *const Type).addr();
47                let v_addr = (self.v as *const Value).addr();
48                if !hist.contains(&(typ_addr, v_addr)) {
49                    hist.insert((typ_addr, v_addr));
50                    TVal { typ: &typ, env: self.env, v }.fmt_int(f, hist)?
51                }
52                Ok(())
53            }
54            (Type::Array(et), Value::Array(a)) => {
55                write!(f, "[")?;
56                for (i, v) in a.iter().enumerate() {
57                    Self { typ: et, env: self.env, v }.fmt_int(f, hist)?;
58                    if i < a.len() - 1 {
59                        write!(f, ", ")?
60                    }
61                }
62                write!(f, "]")
63            }
64            (Type::Array(_), v) => write!(f, "{}", NakedValue(v)),
65            (Type::Map { key, value }, Value::Map(m)) => {
66                write!(f, "{{")?;
67                for (i, (k, v)) in m.into_iter().enumerate() {
68                    Self { typ: key, env: self.env, v: k }.fmt_int(f, hist)?;
69                    write!(f, " => ")?;
70                    Self { typ: value, env: self.env, v: v }.fmt_int(f, hist)?;
71                    if i < m.len() - 1 {
72                        write!(f, ", ")?
73                    }
74                }
75                write!(f, "}}")
76            }
77            (Type::Map { .. }, v) => write!(f, "{}", NakedValue(v)),
78            (Type::ByRef(_), v) => write!(f, "{}", NakedValue(v)),
79            (Type::Struct(flds), Value::Array(a)) => {
80                write!(f, "{{")?;
81                for (i, ((n, et), v)) in flds.iter().zip(a.iter()).enumerate() {
82                    write!(f, "{n}: ")?;
83                    match v {
84                        Value::Array(a) if a.len() == 2 => {
85                            Self { typ: et, env: self.env, v: &a[1] }.fmt_int(f, hist)?
86                        }
87                        _ => write!(f, "err")?,
88                    }
89                    if i < flds.len() - 1 {
90                        write!(f, ", ")?
91                    }
92                }
93                write!(f, "}}")
94            }
95            (Type::Struct(_), v) => write!(f, "{}", NakedValue(v)),
96            (Type::Tuple(flds), Value::Array(a)) => {
97                write!(f, "(")?;
98                for (i, (t, v)) in flds.iter().zip(a.iter()).enumerate() {
99                    Self { typ: t, env: self.env, v }.fmt_int(f, hist)?;
100                    if i < flds.len() - 1 {
101                        write!(f, ", ")?
102                    }
103                }
104                write!(f, ")")
105            }
106            (Type::Tuple(_), v) => write!(f, "{}", NakedValue(v)),
107            (Type::TVar(tv), v) => match &*tv.read().typ.read() {
108                None => write!(f, "{}", NakedValue(v)),
109                Some(typ) => TVal { env: self.env, typ, v }.fmt_int(f, hist),
110            },
111            (Type::Variant(n, flds), Value::Array(a)) if a.len() >= 2 => {
112                write!(f, "`{n}(")?;
113                for (i, (t, v)) in flds.iter().zip(a[1..].iter()).enumerate() {
114                    Self { typ: t, env: self.env, v }.fmt_int(f, hist)?;
115                    if i < flds.len() - 1 {
116                        write!(f, ", ")?
117                    }
118                }
119                write!(f, ")")
120            }
121            (Type::Variant(_, _), Value::String(s)) => write!(f, "`{s}"),
122            (Type::Variant(_, _), v) => write!(f, "{}", NakedValue(v)),
123            (Type::Set(ts), v) => match ts.iter().find(|t| t.is_a(&self.env, v)) {
124                None => write!(f, "{}", NakedValue(v)),
125                Some(t) => Self { typ: t, env: self.env, v }.fmt_int(f, hist),
126            },
127        }
128    }
129}
130
131impl<'a> fmt::Display for TVal<'a> {
132    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
133        self.fmt_int(f, &mut LPooled::take())
134    }
135}
graphix_compiler/typ/tval.rs

graphix_compiler/typ/
tval.rs
