← Back to branch summary

~ubuntu-branches/ubuntu/vivid/typerep/vivid

« back to all changes in this revision

Viewing changes to dev/with_typerep_pp/combination.ml

  • Committer: Package Import Robot
  • Author(s): Hilko Bengen
  • Date: 2014-09-24 23:51:02 UTC
  • Revision ID: package-import@ubuntu.com-20140924235102-0qeq851f02otnnxp
Tags: upstream-111.17.00
Import upstream version 111.17.00

Show diffs side-by-side

added added

removed removed

Lines of Context:
dev/with_typerep_pp/combination.ml
 
1
open Core.Std let _ = _squelch_unused_module_warning_
 
2
open Typerep_experimental.Std
 
3
 
 
4
module Transaction_type = struct
 
5
  module V1 = struct
 
6
    type t =
 
7
    | Trade
 
8
    | Order
 
9
 
 
10
    module Typename_of_t = Make_typename.Make0(struct
 
11
      type non_rec = t
 
12
      type t = non_rec
 
13
      let name = "Combination.Transaction_type.V1.t"
 
14
    end)
 
15
 
 
16
    let typerep_of_t =
 
17
      let name_of_t = Typename_of_t.named in
 
18
      Typerep.Named (name_of_t, Some (lazy (
 
19
        let tag0 = Typerep.Tag.internal_use_only {
 
20
          Typerep.Tag_internal.
 
21
          label = "Trade";
 
22
          rep = typerep_of_tuple0;
 
23
          arity = 0;
 
24
          index = 0;
 
25
          ocaml_repr = 0;
 
26
          tyid = Typename.create ();
 
27
          create = Typerep.Tag_internal.Const Trade;
 
28
        } in
 
29
        let tag1 = Typerep.Tag.internal_use_only {
 
30
          Typerep.Tag_internal.
 
31
          label = "Order";
 
32
          rep = typerep_of_tuple0;
 
33
          arity = 0;
 
34
          index = 1;
 
35
          ocaml_repr = 1;
 
36
          tyid = Typename.create ();
 
37
          create = Typerep.Tag_internal.Const Order;
 
38
        } in
 
39
        let typename = Typerep.Named.typename_of_t name_of_t in
 
40
        let polymorphic = false in
 
41
        let tags = [|
 
42
          Typerep.Variant_internal.Tag tag0;
 
43
          Typerep.Variant_internal.Tag tag1;
 
44
        |] in
 
45
        let value = function
 
46
          | Trade -> Typerep.Variant_internal.Value (tag0, value_tuple0)
 
47
          | Order -> Typerep.Variant_internal.Value (tag1, value_tuple0)
 
48
        in
 
49
        Typerep.Variant (Typerep.Variant.internal_use_only {
 
50
          Typerep.Variant_internal.
 
51
          typename;
 
52
          tags;
 
53
          polymorphic;
 
54
          value;
 
55
        })
 
56
      )))
 
57
  end
 
58
 
 
59
  module V2 = struct
 
60
    type t =
 
61
    | Trade
 
62
    | Order
 
63
    | Journal of string * string
 
64
 
 
65
    module Typename_of_t = Make_typename.Make0(struct
 
66
      type non_rec = t
 
67
      type t = non_rec
 
68
      let name = "Combination.Transaction_type.V2.t"
 
69
    end)
 
70
 
 
71
    let typerep_of_t =
 
72
      let name_of_t = Typename_of_t.named in
 
73
      Typerep.Named (name_of_t, Some (lazy (
 
74
        let tag0 = Typerep.Tag.internal_use_only {
 
75
          Typerep.Tag_internal.
 
76
          label = "Trade";
 
77
          rep = typerep_of_tuple0;
 
78
          arity = 0;
 
79
          index = 0;
 
80
          ocaml_repr = 0;
 
81
          tyid = Typename.create ();
 
82
          create = Typerep.Tag_internal.Const Trade;
 
83
        } in
 
84
        let tag1 = Typerep.Tag.internal_use_only {
 
85
          Typerep.Tag_internal.
 
86
          label = "Order";
 
87
          rep = typerep_of_tuple0;
 
88
          arity = 0;
 
89
          index = 1;
 
90
          ocaml_repr = 1;
 
91
          tyid = Typename.create ();
 
92
          create = Typerep.Tag_internal.Const Order;
 
93
        } in
 
94
        let tag2 = Typerep.Tag.internal_use_only {
 
95
          Typerep.Tag_internal.
 
96
          label = "Journal";
 
97
          rep = typerep_of_tuple2 typerep_of_string typerep_of_string;
 
98
          arity = 2;
 
99
          index = 1;
 
100
          ocaml_repr = 0;
 
101
          tyid = Typename.create ();
 
102
          create = Typerep.Tag_internal.Args (fun (v1, v2) -> Journal (v1, v2));
 
103
        } in
 
104
        let typename = Typerep.Named.typename_of_t name_of_t in
 
105
        let polymorphic = false in
 
106
        let tags = [|
 
107
          Typerep.Variant_internal.Tag tag0;
 
108
          Typerep.Variant_internal.Tag tag1;
 
109
          Typerep.Variant_internal.Tag tag2;
 
110
        |] in
 
111
        let value = function
 
112
          | Trade -> Typerep.Variant_internal.Value (tag0, value_tuple0)
 
113
          | Order -> Typerep.Variant_internal.Value (tag1, value_tuple0)
 
114
          | Journal (v1, v2) -> Typerep.Variant_internal.Value (tag2, (v1, v2))
 
115
        in
 
116
        Typerep.Variant (Typerep.Variant.internal_use_only {
 
117
          Typerep.Variant_internal.
 
118
          typename;
 
119
          tags;
 
120
          polymorphic;
 
121
          value;
 
122
        })
 
123
      )))
 
124
  end
 
125
end
 
126
 
 
127
module V1 = struct
 
128
  type t = {
 
129
    transaction_type : Transaction_type.V1.t;
 
130
    username : string;
 
131
  }
 
132
 
 
133
  module Typename_of_t = Make_typename.Make0(struct
 
134
    type non_rec = t
 
135
    type t = non_rec
 
136
    let name = "Combination.V1.t"
 
137
  end)
 
138
 
 
139
  let typerep_of_t =
 
140
    let name_of_t = Typename_of_t.named in
 
141
    Typerep.Named (name_of_t, Some(lazy(
 
142
      let field0 = Typerep.Field.internal_use_only {
 
143
        Typerep.Field_internal.
 
144
        label = "transaction_type";
 
145
        index = 0;
 
146
        rep = Transaction_type.V1.typerep_of_t;
 
147
        tyid = Typename.create ();
 
148
        get = (fun t -> t.transaction_type);
 
149
      } in
 
150
      let field1 = Typerep.Field.internal_use_only {
 
151
        Typerep.Field_internal.
 
152
        label = "username";
 
153
        index = 1;
 
154
        rep = typerep_of_string;
 
155
        tyid = Typename.create ();
 
156
        get = (fun t -> t.username);
 
157
      } in
 
158
      let typename = Typerep.Named.typename_of_t name_of_t in
 
159
      let has_double_array_tag =
 
160
        Typerep_obj.has_double_array_tag {
 
161
          transaction_type = Typerep_obj.double_array_value;
 
162
          username = Typerep_obj.double_array_value;
 
163
        }
 
164
      in
 
165
      let fields = [|
 
166
        Typerep.Record_internal.Field field0;
 
167
        Typerep.Record_internal.Field field1;
 
168
      |] in
 
169
      let create { Typerep.Record_internal.get } =
 
170
        let transaction_type = get field0 in
 
171
        let username = get field1 in
 
172
        { transaction_type ; username }
 
173
      in
 
174
      Typerep.Record (Typerep.Record.internal_use_only {
 
175
        Typerep.Record_internal.
 
176
        typename;
 
177
        has_double_array_tag;
 
178
        fields;
 
179
        create;
 
180
      })
 
181
    )))
 
182
end
 
183
 
 
184
module V2 = struct
 
185
  type t = {
 
186
    transaction_type : Transaction_type.V2.t;
 
187
    username : string;
 
188
    tags : (string * string) list;
 
189
  }
 
190
 
 
191
  module Typename_of_t = Make_typename.Make0(struct
 
192
    type non_rec = t
 
193
    type t = non_rec
 
194
    let name = "Combination.V2.t"
 
195
  end)
 
196
 
 
197
  let typerep_of_t =
 
198
    let name_of_t = Typename_of_t.named in
 
199
    Typerep.Named (name_of_t, Some(lazy(
 
200
      let field0 = Typerep.Field.internal_use_only {
 
201
        Typerep.Field_internal.
 
202
        label = "transaction_type";
 
203
        index = 0;
 
204
        rep = Transaction_type.V2.typerep_of_t;
 
205
        tyid = Typename.create ();
 
206
        get = (fun t -> t.transaction_type);
 
207
      } in
 
208
      let field1 = Typerep.Field.internal_use_only {
 
209
        Typerep.Field_internal.
 
210
        label = "username";
 
211
        index = 1;
 
212
        rep = typerep_of_string;
 
213
        tyid = Typename.create ();
 
214
        get = (fun t -> t.username);
 
215
      } in
 
216
      let field2 = Typerep.Field.internal_use_only {
 
217
        Typerep.Field_internal.
 
218
        label = "tags";
 
219
        index = 2;
 
220
        rep = typerep_of_list (typerep_of_tuple2 typerep_of_string typerep_of_string);
 
221
        tyid = Typename.create ();
 
222
        get = (fun t -> t.tags);
 
223
      } in
 
224
      let typename = Typerep.Named.typename_of_t name_of_t in
 
225
      let has_double_array_tag =
 
226
        Typerep_obj.has_double_array_tag {
 
227
          transaction_type = Typerep_obj.double_array_value;
 
228
          username = Typerep_obj.double_array_value;
 
229
          tags = Typerep_obj.double_array_value;
 
230
        }
 
231
      in
 
232
      let fields = [|
 
233
        Typerep.Record_internal.Field field0;
 
234
        Typerep.Record_internal.Field field1;
 
235
        Typerep.Record_internal.Field field2;
 
236
      |] in
 
237
      let create { Typerep.Record_internal.get } =
 
238
        let transaction_type = get field0 in
 
239
        let username = get field1 in
 
240
        let tags = get field2 in
 
241
        { transaction_type ; username ; tags }
 
242
      in
 
243
      Typerep.Record (Typerep.Record.internal_use_only {
 
244
        Typerep.Record_internal.
 
245
        typename;
 
246
        has_double_array_tag;
 
247
        fields;
 
248
        create;
 
249
      })
 
250
    )))
 
251
end
 
252
 
 
253
type t =
 
254
| V1 of V1.t
 
255
| V2 of V2.t
 
256
 
 
257
module Typename_of_t = Make_typename.Make0(struct
 
258
  type non_rec = t
 
259
  type t = non_rec
 
260
  let name = "Combination.t"
 
261
end)
 
262
 
 
263
let typerep_of_t : t Typerep.t =
 
264
  let name_of_t = Typename_of_t.named in
 
265
  Typerep.Named (name_of_t, Some (lazy (
 
266
    let tag0 = Typerep.Tag.internal_use_only {
 
267
      Typerep.Tag_internal.
 
268
      label = "V1";
 
269
      rep = V1.typerep_of_t;
 
270
      arity = 1;
 
271
      index = 0;
 
272
      ocaml_repr = 0;
 
273
      tyid = Typename.create ();
 
274
      create = Typerep.Tag_internal.Args (fun x -> V1 x);
 
275
    } in
 
276
    let tag1 = Typerep.Tag.internal_use_only {
 
277
      Typerep.Tag_internal.
 
278
      label = "V2";
 
279
      rep = V2.typerep_of_t;
 
280
      arity = 1;
 
281
      index = 1;
 
282
      ocaml_repr = 1;
 
283
      tyid = Typename.create ();
 
284
      create = Typerep.Tag_internal.Args (fun x -> V2 x)
 
285
    } in
 
286
    let typename = Typerep.Named.typename_of_t name_of_t in
 
287
    let polymorphic = false in
 
288
    let tags = [|
 
289
      Typerep.Variant_internal.Tag tag0;
 
290
      Typerep.Variant_internal.Tag tag1;
 
291
    |] in
 
292
    let value = function
 
293
      | V1 x -> Typerep.Variant_internal.Value (tag0, x)
 
294
      | V2 x -> Typerep.Variant_internal.Value (tag1, x)
 
295
    in
 
296
    Typerep.Variant (Typerep.Variant.internal_use_only {
 
297
      Typerep.Variant_internal.
 
298
      typename;
 
299
      tags;
 
300
      polymorphic;
 
301
      value;
 
302
    })
 
303
  )))