package json-derivers

  1. Overview
  2. Docs

Source file jsonm.ml

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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
open Import

type value =
  [ `Null
  | `Bool of bool
  | `Float of float
  | `String of string
  | `A of value list
  | `O of (string * value) list ]
[@@deriving_inline compare, sexp, hash]
let _ = fun (_ : value)  -> ()
let rec compare_value : value -> value -> int =
  fun a__001_  ->
    fun b__002_  ->
      if Ppx_compare_lib.phys_equal a__001_ b__002_
      then 0
      else
        (match (a__001_, b__002_) with
         | (`Null,`Null) -> 0
         | (`Bool _left__003_,`Bool _right__004_) ->
             compare_bool _left__003_ _right__004_
         | (`Float _left__005_,`Float _right__006_) ->
             compare_float _left__005_ _right__006_
         | (`String _left__007_,`String _right__008_) ->
             compare_string _left__007_ _right__008_
         | (`A _left__009_,`A _right__010_) ->
             compare_list compare_value _left__009_ _right__010_
         | (`O _left__013_,`O _right__014_) ->
             compare_list
               (fun a__015_  ->
                  fun b__016_  ->
                    let (t__017_,t__018_) = a__015_  in
                    let (t__019_,t__020_) = b__016_  in
                    match compare_string t__017_ t__019_ with
                    | 0 -> compare_value t__018_ t__020_
                    | n -> n) _left__013_ _right__014_
         | (x,y) -> Ppx_compare_lib.polymorphic_compare x y)

let _ = compare_value
let rec __value_of_sexp__ : Sexplib.Sexp.t -> value =
  let _tp_loc = "jsonm.ml.value"  in
  function
  | Sexplib.Sexp.Atom atom as _sexp ->
      (match atom with
       | "Null" -> `Null
       | "Bool" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | "Float" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | "String" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | "A" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | "O" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | _ -> Sexplib.Conv_error.no_variant_match ())
  | Sexplib.Sexp.List ((Sexplib.Sexp.Atom atom)::sexp_args) as _sexp ->
      (match atom with
       | "Bool" as _tag ->
           (match sexp_args with
            | v0::[] -> let v0 = bool_of_sexp v0  in `Bool v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "Float" as _tag ->
           (match sexp_args with
            | v0::[] -> let v0 = float_of_sexp v0  in `Float v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "String" as _tag ->
           (match sexp_args with
            | v0::[] -> let v0 = string_of_sexp v0  in `String v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "A" as _tag ->
           (match sexp_args with
            | v0::[] -> let v0 = list_of_sexp value_of_sexp v0  in `A v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "O" as _tag ->
           (match sexp_args with
            | v0::[] ->
                let v0 =
                  list_of_sexp
                    (function
                     | Sexplib.Sexp.List (v0::v1::[]) ->
                         let v0 = string_of_sexp v0

                         and v1 = value_of_sexp v1
                          in (v0, v1)
                     | sexp ->
                         Sexplib.Conv_error.tuple_of_size_n_expected _tp_loc
                           2 sexp) v0
                   in
                `O v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "Null" -> Sexplib.Conv_error.ptag_no_args _tp_loc _sexp
       | _ -> Sexplib.Conv_error.no_variant_match ())
  | Sexplib.Sexp.List ((Sexplib.Sexp.List _)::_) as sexp ->
      Sexplib.Conv_error.nested_list_invalid_poly_var _tp_loc sexp
  | Sexplib.Sexp.List [] as sexp ->
      Sexplib.Conv_error.empty_list_invalid_poly_var _tp_loc sexp

and value_of_sexp : Sexplib.Sexp.t -> value =
  let _tp_loc = "jsonm.ml.value"  in
  fun sexp  ->
    try __value_of_sexp__ sexp
    with
    | Sexplib.Conv_error.No_variant_match  ->
        Sexplib.Conv_error.no_matching_variant_found _tp_loc sexp

let _ = __value_of_sexp__

and _ = value_of_sexp

let rec sexp_of_value : value -> Sexplib.Sexp.t =
  function
  | `Null -> Sexplib.Sexp.Atom "Null"
  | `Bool v0 -> Sexplib.Sexp.List [Sexplib.Sexp.Atom "Bool"; sexp_of_bool v0]
  | `Float v0 ->
      Sexplib.Sexp.List [Sexplib.Sexp.Atom "Float"; sexp_of_float v0]
  | `String v0 ->
      Sexplib.Sexp.List [Sexplib.Sexp.Atom "String"; sexp_of_string v0]
  | `A v0 ->
      Sexplib.Sexp.List
        [Sexplib.Sexp.Atom "A"; sexp_of_list sexp_of_value v0]
  | `O v0 ->
      Sexplib.Sexp.List
        [Sexplib.Sexp.Atom "O";
        sexp_of_list
          (function
           | (v0,v1) ->
               let v0 = sexp_of_string v0

               and v1 = sexp_of_value v1
                in Sexplib.Sexp.List [v0; v1]) v0]

let _ = sexp_of_value
let rec (hash_fold_value :
  Ppx_hash_lib.Std.Hash.state -> value -> Ppx_hash_lib.Std.Hash.state) =
  fun hsv  ->
    fun arg  ->
      match arg with
      | `Null -> Ppx_hash_lib.Std.Hash.fold_int hsv 870828711
      | `Bool _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 737456202  in
          hash_fold_bool hsv _v
      | `Float _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 365180284  in
          hash_fold_float hsv _v
      | `String _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv (-976970511)  in
          hash_fold_string hsv _v
      | `A _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 65  in
          hash_fold_list hash_fold_value hsv _v
      | `O _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 79  in
          hash_fold_list
            (fun hsv  ->
               fun arg  ->
                 let (e0,e1) = arg  in
                 let hsv = hash_fold_string hsv e0  in
                 let hsv = hash_fold_value hsv e1  in hsv) hsv _v

and (hash_value : value -> Ppx_hash_lib.Std.Hash.hash_value) =
  let func arg =
    Ppx_hash_lib.Std.Hash.get_hash_value
      (let hsv = Ppx_hash_lib.Std.Hash.create ()  in hash_fold_value hsv arg)
     in
  fun x  -> func x

let _ = hash_fold_value

and _ = hash_value

[@@@deriving.end]

type t =
  [ `A of value list
  | `O of (string * value) list ]
[@@deriving_inline compare, sexp, hash]
let _ = fun (_ : t)  -> ()
let compare : t -> t -> int =
  fun a__021_  ->
    fun b__022_  ->
      if Ppx_compare_lib.phys_equal a__021_ b__022_
      then 0
      else
        (match (a__021_, b__022_) with
         | (`A _left__023_,`A _right__024_) ->
             compare_list compare_value _left__023_ _right__024_
         | (`O _left__027_,`O _right__028_) ->
             compare_list
               (fun a__029_  ->
                  fun b__030_  ->
                    let (t__031_,t__032_) = a__029_  in
                    let (t__033_,t__034_) = b__030_  in
                    match compare_string t__031_ t__033_ with
                    | 0 -> compare_value t__032_ t__034_
                    | n -> n) _left__027_ _right__028_
         | (x,y) -> Ppx_compare_lib.polymorphic_compare x y)

let _ = compare
let __t_of_sexp__ : Sexplib.Sexp.t -> t =
  let _tp_loc = "jsonm.ml.t"  in
  function
  | Sexplib.Sexp.Atom atom as _sexp ->
      (match atom with
       | "A" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | "O" -> Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp
       | _ -> Sexplib.Conv_error.no_variant_match ())
  | Sexplib.Sexp.List ((Sexplib.Sexp.Atom atom)::sexp_args) as _sexp ->
      (match atom with
       | "A" as _tag ->
           (match sexp_args with
            | v0::[] -> let v0 = list_of_sexp value_of_sexp v0  in `A v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | "O" as _tag ->
           (match sexp_args with
            | v0::[] ->
                let v0 =
                  list_of_sexp
                    (function
                     | Sexplib.Sexp.List (v0::v1::[]) ->
                         let v0 = string_of_sexp v0

                         and v1 = value_of_sexp v1
                          in (v0, v1)
                     | sexp ->
                         Sexplib.Conv_error.tuple_of_size_n_expected _tp_loc
                           2 sexp) v0
                   in
                `O v0
            | _ ->
                Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp)
       | _ -> Sexplib.Conv_error.no_variant_match ())
  | Sexplib.Sexp.List ((Sexplib.Sexp.List _)::_) as sexp ->
      Sexplib.Conv_error.nested_list_invalid_poly_var _tp_loc sexp
  | Sexplib.Sexp.List [] as sexp ->
      Sexplib.Conv_error.empty_list_invalid_poly_var _tp_loc sexp

let _ = __t_of_sexp__
let t_of_sexp : Sexplib.Sexp.t -> t =
  let _tp_loc = "jsonm.ml.t"  in
  fun sexp  ->
    try __t_of_sexp__ sexp
    with
    | Sexplib.Conv_error.No_variant_match  ->
        Sexplib.Conv_error.no_matching_variant_found _tp_loc sexp

let _ = t_of_sexp
let sexp_of_t : t -> Sexplib.Sexp.t =
  function
  | `A v0 ->
      Sexplib.Sexp.List
        [Sexplib.Sexp.Atom "A"; sexp_of_list sexp_of_value v0]
  | `O v0 ->
      Sexplib.Sexp.List
        [Sexplib.Sexp.Atom "O";
        sexp_of_list
          (function
           | (v0,v1) ->
               let v0 = sexp_of_string v0

               and v1 = sexp_of_value v1
                in Sexplib.Sexp.List [v0; v1]) v0]

let _ = sexp_of_t
let (hash_fold_t :
  Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state) =
  fun hsv  ->
    fun arg  ->
      match arg with
      | `A _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 65  in
          hash_fold_list hash_fold_value hsv _v
      | `O _v ->
          let hsv = Ppx_hash_lib.Std.Hash.fold_int hsv 79  in
          hash_fold_list
            (fun hsv  ->
               fun arg  ->
                 let (e0,e1) = arg  in
                 let hsv = hash_fold_string hsv e0  in
                 let hsv = hash_fold_value hsv e1  in hsv) hsv _v

let _ = hash_fold_t
let (hash : t -> Ppx_hash_lib.Std.Hash.hash_value) =
  let func arg =
    Ppx_hash_lib.Std.Hash.get_hash_value
      (let hsv = Ppx_hash_lib.Std.Hash.create ()  in hash_fold_t hsv arg)
     in
  fun x  -> func x
let _ = hash
[@@@deriving.end]
OCaml

Innovation. Community. Security.