sequoia-seq 0.1.0

Sequoia declarative language (.seq): parser, checker, lowering to views
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

use std::rc::Rc;

use crate::bindings::SeqRowData;

#[derive(Clone)]
pub(crate) enum Value {
    Int(i64),

    Float(f64),

    Str(Rc<String>),

    Bool(bool),

    Tuple(Rc<Vec<Value>>),

    Option(Option<Box<Value>>),

    Row(SeqRowData),

    Null,
}

impl std::fmt::Debug for Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Int(i) => write!(f, "Int({i})"),
            Self::Float(v) => write!(f, "Float({v})"),
            Self::Str(s) => write!(f, "Str({s:?})"),
            Self::Bool(b) => write!(f, "Bool({b})"),
            Self::Tuple(items) => write!(f, "Tuple({items:?})"),
            Self::Option(v) => match v {
                Some(x) => write!(f, "Some({x:?})"),
                None => write!(f, "None"),
            },
            Self::Row(row) => write!(f, "Row(id: {})", row.id),
            Self::Null => write!(f, "Null"),
        }
    }
}

impl Value {
    pub(crate) fn type_name(&self) -> &'static str {
        match self {
            Self::Int(_) => "Int",
            Self::Float(_) => "Float",
            Self::Str(_) => "String",
            Self::Bool(_) => "Bool",
            Self::Tuple(_) => "krotka",
            Self::Option(_) => "Option",
            Self::Row(_) => "wiersz",
            Self::Null => "no value",
        }
    }

    pub(crate) fn as_str(&self) -> Option<&str> {
        match self {
            Self::Str(s) => Some(s.as_str()),
            _ => None,
        }
    }

    pub(crate) fn as_bool(&self) -> Option<bool> {
        match self {
            Self::Bool(b) => Some(*b),
            _ => None,
        }
    }

    pub(crate) fn as_f64(&self) -> Option<f64> {
        match self {
            Self::Int(i) => Some(*i as f64),
            Self::Float(f) => Some(*f),
            _ => None,
        }
    }

    pub(crate) fn is_number(&self) -> bool {
        matches!(self, Self::Int(_) | Self::Float(_))
    }
}