gluon 0.18.2

A static, type inferred programming language for application embedding
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
117
118
119
120
121

//! JSON serialization
//!
//! _This module is only available if gluon is compiled with the `serialization` feature._

let { Value } = import! std.json
let prim = import! std.json.prim
let { Result, ? } = import! std.result
let { for } = import! std.traversable
let { map } = import! std.functor
let { ? } = import! std.array
let { Map, ? } = import! std.map

type Error = String
type ValueSerializer a = { serialize : a -> Result Error Value }

#[implicit]
type Serialize a = ValueSerializer a

let serialize ?ser : [Serialize a] -> a -> Result Error Value = ser.serialize

/// Serializes `a` to a JSON without whitespace string
///
/// ```
/// let { ? } = import! std.effect
/// let { Value, to_string, ? } = import! std.json.ser
/// let { Result, ? } = import! std.result
/// let { singleton, ? } = import! std.map
/// let { (<>) } = import! std.semigroup
/// let { assert_eq, ? } = import! std.test
///
/// seq assert_eq (to_string "string") (Ok r#""string""#)
///
/// let expected = r#"[1,2,3]"#
/// seq assert_eq (to_string [1, 2, 3]) (Ok expected)
///
/// let expected = r#"{"field":1}"#
/// assert_eq (to_string (singleton "field" 1)) (Ok expected)
/// ```
let to_string v : [Serialize a] -> a -> Result Error String =
    do value = serialize v
    prim.serialize value


/// Serializes `a` to a JSON string
///
/// ```
/// let { ? } = import! std.effect
/// let { Value, to_string_pretty, ? } = import! std.json.ser
/// let { Result, ? } = import! std.result
/// let { singleton, ? } = import! std.map
/// let { (<>) } = import! std.semigroup
/// let { assert_eq, ? } = import! std.test
///
/// seq assert_eq (to_string_pretty "string") (Ok r#""string""#)
///
/// let expected = r#"[
///   1,
///   2,
///   3
/// ]"#
/// seq assert_eq (to_string_pretty [1, 2, 3]) (Ok expected)
///
/// let expected = r#"{
///   "field": 1
/// }"#
/// assert_eq (to_string_pretty (singleton "field" 1)) (Ok expected)
/// ```
let to_string_pretty v : [Serialize a] -> a -> Result Error String =
    do value = serialize v
    prim.serialize_pretty value

let serialize_unit : Serialize () = { serialize = \_ -> Ok Null }

let serialize_int : Serialize Int = { serialize = \i -> Ok (Int i) }

let serialize_bool : Serialize Bool = { serialize = \i -> Ok (Bool i) }

let serialize_float : Serialize Float = { serialize = \i -> Ok (Float i) }

let serialize_string : Serialize String = { serialize = \i -> Ok (String i) }

let serialize_option : [Serialize a] -> Serialize (Option a) =
    let serialize = \i ->
        match i with
        | Some x -> serialize x
        | None -> Ok Null
    { serialize }

let serialize_array : [Serialize a] -> Serialize (Array a) =
    let serialize = \i ->
        map Array (for i serialize)
    { serialize }

let serialize_map : [Serialize a] -> Serialize (Map String a) =
    let serialize = \i ->
        map Object (for i serialize)
    { serialize }

let serialize_value : Serialize Value = { serialize = Ok }

{
    Value,
    ValueSerializer,
    Serialize,
    Error,

    serialize,

    to_string,
    to_string_pretty,

    serialize_unit,
    serialize_int,
    serialize_bool,
    serialize_float,
    serialize_string,
    serialize_option,
    serialize_array,
    serialize_map,
    serialize_value,
}