geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

use crate::gleam_stdlib::{DictOf, Dynamic, DynamicDecodeError, GleamError, GleamOk, GleamResult};
use crate::{
    HostCustomConstructorAt, HostCustomConstructorDefinition, HostCustomConstructorList,
    HostCustomConstructorListEnd, HostCustomField, HostCustomFieldList, HostCustomFieldListEnd,
    HostCustomIndex0, HostCustomIndexNext, HostCustomSchema, HostCustomType, HostExternalSchema,
    HostExternalType, HostListType, HostTupleType, HostTypeIndex0, HostTypeIndexNext, HostTypeList,
    HostTypeListEnd,
};
use ecow::EcoString;

pub(super) struct JsonSchema;

pub(super) struct DecodeErrorSchema;
pub(super) struct UnexpectedEndOfInputDefinition;
pub(super) struct UnexpectedByteDefinition;
pub(super) struct UnexpectedSequenceDefinition;
pub(super) struct UnableToDecodeDefinition;
pub(super) struct UnexpectedByteField;
pub(super) struct UnexpectedSequenceField;
pub(super) struct UnableToDecodeField;

pub(super) type Json = HostExternalType<JsonSchema>;
pub(super) type JsonList = HostListType<Json>;

pub(super) type DecodeError = HostCustomType<DecodeErrorSchema>;
pub(super) type UnexpectedEndOfInput =
    HostCustomConstructorAt<DecodeError, HostCustomIndex0, UnexpectedEndOfInputDefinition>;
pub(super) type UnexpectedByte = HostCustomConstructorAt<
    DecodeError,
    HostCustomIndexNext<HostCustomIndex0>,
    UnexpectedByteDefinition,
>;
pub(super) type UnexpectedSequence = HostCustomConstructorAt<
    DecodeError,
    HostCustomIndexNext<HostCustomIndexNext<HostCustomIndex0>>,
    UnexpectedSequenceDefinition,
>;
pub(super) type JsonDynamicResult = GleamResult<Dynamic, DecodeError>;
pub(super) type JsonDynamicOk = GleamOk<Dynamic, DecodeError>;
pub(super) type JsonDynamicError = GleamError<Dynamic, DecodeError>;

pub(super) type DynamicList = HostListType<Dynamic>;
pub(super) type DynamicDict = DictOf<Dynamic, Dynamic>;
pub(super) type DecodeConstructions = HostTypeList<
    Dynamic,
    HostTypeList<
        DynamicList,
        HostTypeList<DynamicDict, HostTypeList<DecodeError, HostTypeListEnd>>,
    >,
>;
pub(super) type DecodeDynamicIndex = HostTypeIndex0;
pub(super) type DecodeListIndex = HostTypeIndexNext<DecodeDynamicIndex>;
pub(super) type DecodeDictIndex = HostTypeIndexNext<DecodeListIndex>;
pub(super) type DecodeErrorIndex = HostTypeIndexNext<DecodeDictIndex>;

pub(super) type ObjectEntryElements = HostTypeList<EcoString, HostTypeList<Json, HostTypeListEnd>>;
pub(super) type ObjectEntry = HostTupleType<ObjectEntryElements>;
pub(super) type ObjectEntries = HostListType<ObjectEntry>;

impl HostExternalSchema for JsonSchema {
    const PACKAGE: &'static str = "gleam_json";
    const MODULE: &'static str = "gleam/json";
    const NAME: &'static str = "Json";
    const PARAMETER_COUNT: usize = 0;
}

impl HostCustomConstructorDefinition for UnexpectedEndOfInputDefinition {
    const NAME: &'static str = "UnexpectedEndOfInput";

    type Fields = HostCustomFieldListEnd;
}

impl HostCustomField for UnexpectedByteField {
    const LABEL: Option<&'static str> = None;

    type Type = EcoString;
}

impl HostCustomConstructorDefinition for UnexpectedByteDefinition {
    const NAME: &'static str = "UnexpectedByte";

    type Fields = HostCustomFieldList<UnexpectedByteField, HostCustomFieldListEnd>;
}

impl HostCustomField for UnexpectedSequenceField {
    const LABEL: Option<&'static str> = None;

    type Type = EcoString;
}

impl HostCustomConstructorDefinition for UnexpectedSequenceDefinition {
    const NAME: &'static str = "UnexpectedSequence";

    type Fields = HostCustomFieldList<UnexpectedSequenceField, HostCustomFieldListEnd>;
}

impl HostCustomField for UnableToDecodeField {
    const LABEL: Option<&'static str> = None;

    type Type = HostListType<DynamicDecodeError>;
}

impl HostCustomConstructorDefinition for UnableToDecodeDefinition {
    const NAME: &'static str = "UnableToDecode";

    type Fields = HostCustomFieldList<UnableToDecodeField, HostCustomFieldListEnd>;
}

impl HostCustomSchema for DecodeErrorSchema {
    const PACKAGE: &'static str = "gleam_json";
    const MODULE: &'static str = "gleam/json";
    const NAME: &'static str = "DecodeError";
    const PARAMETER_COUNT: usize = 0;

    type Constructors = HostCustomConstructorList<
        UnexpectedEndOfInputDefinition,
        HostCustomConstructorList<
            UnexpectedByteDefinition,
            HostCustomConstructorList<
                UnexpectedSequenceDefinition,
                HostCustomConstructorList<UnableToDecodeDefinition, HostCustomConstructorListEnd>,
            >,
        >,
    >;
}

#[cfg(test)]
mod tests {
    use super::{DecodeErrorSchema, JsonSchema};
    use crate::{
        HostCustomConstructorSchema, HostCustomFieldSchema, HostCustomTypeSchema,
        HostExternalTypeSchema, HostSchemaType,
    };

    #[test]
    fn describes_the_exact_official_json_and_decode_error_schemas() {
        assert_eq!(
            HostExternalTypeSchema::of::<JsonSchema>(),
            HostExternalTypeSchema::new("gleam_json", "gleam/json", "Json", 0),
        );
        assert_eq!(
            HostCustomTypeSchema::of::<DecodeErrorSchema>(),
            HostCustomTypeSchema::new(
                "gleam_json",
                "gleam/json",
                "DecodeError",
                0,
                [
                    HostCustomConstructorSchema::new(
                        "UnexpectedEndOfInput",
                        Vec::<HostCustomFieldSchema>::new(),
                    ),
                    HostCustomConstructorSchema::new(
                        "UnexpectedByte",
                        [HostCustomFieldSchema::new(
                            None::<&str>,
                            HostSchemaType::String,
                        )],
                    ),
                    HostCustomConstructorSchema::new(
                        "UnexpectedSequence",
                        [HostCustomFieldSchema::new(
                            None::<&str>,
                            HostSchemaType::String,
                        )],
                    ),
                    HostCustomConstructorSchema::new(
                        "UnableToDecode",
                        [HostCustomFieldSchema::new(
                            None::<&str>,
                            HostSchemaType::list(HostSchemaType::custom(
                                "gleam_stdlib",
                                "gleam/dynamic/decode",
                                "DecodeError",
                                Vec::new(),
                            )),
                        )],
                    ),
                ],
            ),
        );
    }
}