shape-runtime 0.3.1

Bytecode compiler, builtins, and runtime infrastructure for Shape
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

/// @module std::core::json_value
/// Typed JSON value ADT.
///
/// `json.parse(text)` returns `Result<Json>`. Pattern matching and
/// navigation methods provide typed access to unknown JSON structures.
/// `TryFrom<Json>` impls auto-derive `TryInto` so `as?` works:
///
///   let name = (data.get("name") as? string)?

/// Algebraic data type representing JSON values in Shape.
///
/// `Int` is used for JSON numbers that fit in `i64` and have no fractional
/// part; `Number` is used for everything else. This preserves the
/// `int` / `number` distinction at the boundary so downstream code can
/// recover the precise type without a follow-up coercion.
pub enum Json {
    Null,
    Bool(bool),
    Int(int),
    Number(number),
    Str(string),
    Array(any),
    Object(any),
}

extend Json {
    /// Access a field in a JSON object by key. Returns `Json::Null` for
    /// non-object values or missing keys.
    method get(key: string) -> Json {
        match self {
            Json::Object(obj) => {
                let result = __json_object_get(obj, key)
                result
            },
            _ => Json::Null,
        }
    }

    /// Access an element in a JSON array by index. Returns `Json::Null`
    /// for non-array values or out-of-range indices.
    method at(index: number) -> Json {
        match self {
            Json::Array(arr) => {
                let result = __json_array_at(arr, index)
                result
            },
            _ => Json::Null,
        }
    }

    /// Check if this value is `Json::Null`.
    method is_null() -> bool {
        match self {
            Json::Null => true,
            _ => false,
        }
    }

    /// Return the keys of a JSON object, or an empty array for non-objects.
    method keys() -> Array<string> {
        match self {
            Json::Object(obj) => __json_object_keys(obj),
            _ => [],
        }
    }

    /// Return the length of a JSON array or object, or 0.
    method len() -> number {
        match self {
            Json::Array(arr) => __json_array_len(arr),
            Json::Object(obj) => __json_object_len(obj),
            _ => 0,
        }
    }
}

impl TryFrom<Json> for string {
    method tryFrom(value: Json) -> Result<string, AnyError> {
        match value {
            Json::Str(s) => Ok(s),
            _ => Err("Json value is not a string"),
        }
    }
}

impl TryFrom<Json> for number {
    method tryFrom(value: Json) -> Result<number, AnyError> {
        match value {
            Json::Number(n) => Ok(n),
            Json::Int(i) => Ok(i as number),
            _ => Err("Json value is not a number"),
        }
    }
}

impl TryFrom<Json> for int {
    method tryFrom(value: Json) -> Result<int, AnyError> {
        match value {
            Json::Int(i) => Ok(i),
            _ => Err("Json value is not an int"),
        }
    }
}

impl TryFrom<Json> for bool {
    method tryFrom(value: Json) -> Result<bool, AnyError> {
        match value {
            Json::Bool(b) => Ok(b),
            _ => Err("Json value is not a bool"),
        }
    }
}