pyret-npm 0.1.22 → 0.1.23
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +5 -2
- package/pyret-lang/lib/jglr/cyclicJSON.js +174 -0
- package/pyret-lang/lib/jglr/jglr.js +341 -0
- package/pyret-lang/lib/jglr/rnglr.js +2687 -0
- package/pyret-lang/src/js/base/js-numbers.js +4311 -0
- package/pyret-lang/src/js/base/pyret-tokenizer.js +579 -0
- package/pyret-lang/src/js/base/type-util.js +553 -0
|
@@ -0,0 +1,553 @@
|
|
|
1
|
+
define("pyret-base/js/type-util", [], function() {
|
|
2
|
+
|
|
3
|
+
var any = { "tag": "any" };
|
|
4
|
+
var string = { "tag": "name", "module": "builtin", "name": "String" }
|
|
5
|
+
var number = { "tag": "name", "module": "builtin", "name": "Number" }
|
|
6
|
+
var boolean = { "tag": "name", "module": "builtin", "name": "Boolean" }
|
|
7
|
+
var nothing = { "tag": "name", "module": "builtin", "name": "Nothing" }
|
|
8
|
+
|
|
9
|
+
function forall(args, onto) {
|
|
10
|
+
if(!Array.isArray(args)) { throw "Expected list for args, but got " + String(args); }
|
|
11
|
+
args.forEach(function(a) {
|
|
12
|
+
if(typeof a !== "string") { throw "Type args must be strings, but got: " + String(a); }
|
|
13
|
+
});
|
|
14
|
+
return {
|
|
15
|
+
tag: "forall",
|
|
16
|
+
args: args,
|
|
17
|
+
onto: onto
|
|
18
|
+
}
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
function arrow(args, ret) {
|
|
22
|
+
if(!Array.isArray(args)) { throw "Expected list for arrow args, but got " + String(args); }
|
|
23
|
+
return {
|
|
24
|
+
tag: "arrow",
|
|
25
|
+
args: args,
|
|
26
|
+
ret: ret
|
|
27
|
+
};
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
function tyapp(onto, args) {
|
|
31
|
+
if(!Array.isArray(args)) { throw "Expected list for tyapp args, but got " + String(args); }
|
|
32
|
+
return {
|
|
33
|
+
tag: "tyapp",
|
|
34
|
+
onto: onto,
|
|
35
|
+
args: args
|
|
36
|
+
};
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
function tyvar(name) {
|
|
40
|
+
return {
|
|
41
|
+
tag: "tyvar",
|
|
42
|
+
name: name
|
|
43
|
+
};
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
function builtinName(name) {
|
|
47
|
+
return {
|
|
48
|
+
tag: "name",
|
|
49
|
+
module: "builtin",
|
|
50
|
+
name: name
|
|
51
|
+
};
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function libName(lib, name) {
|
|
55
|
+
return {
|
|
56
|
+
tag: "name",
|
|
57
|
+
module: "pyret-builtin://" + lib,
|
|
58
|
+
name: name
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
function localType(name) {
|
|
63
|
+
return {
|
|
64
|
+
tag: "name",
|
|
65
|
+
module: "LOCAL",
|
|
66
|
+
name: name
|
|
67
|
+
};
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
function record(fields) {
|
|
71
|
+
return {
|
|
72
|
+
tag: "record",
|
|
73
|
+
fields: fields
|
|
74
|
+
};
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
function dataRefinement(basetype, variant) {
|
|
78
|
+
return {
|
|
79
|
+
tag: "data-refinement",
|
|
80
|
+
basetype: basetype,
|
|
81
|
+
variant: variant
|
|
82
|
+
};
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
function dataType(origin, name, params, variants, methods) {
|
|
86
|
+
return {
|
|
87
|
+
tag: "data",
|
|
88
|
+
origin: origin,
|
|
89
|
+
name: name,
|
|
90
|
+
params: params,
|
|
91
|
+
variants: variants,
|
|
92
|
+
methods: methods
|
|
93
|
+
};
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
function variant(name, vmembers, withmembers) {
|
|
97
|
+
return {
|
|
98
|
+
tag: "variant",
|
|
99
|
+
name: name,
|
|
100
|
+
vmembers: vmembers,
|
|
101
|
+
withmembers: withmembers
|
|
102
|
+
};
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
function singletonVariant(name, withmembers) {
|
|
106
|
+
return {
|
|
107
|
+
tag: "singleton-variant",
|
|
108
|
+
name: name,
|
|
109
|
+
withmembers: withmembers
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
function variantMember(name, kind, typ) {
|
|
114
|
+
return {
|
|
115
|
+
tag: "variant-member",
|
|
116
|
+
kind: kind,
|
|
117
|
+
typ: typ
|
|
118
|
+
};
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
function bindToPyret(runtime, value, shorthands) {
|
|
122
|
+
var origin = runtime.makeObject({ provided: false });
|
|
123
|
+
if(!value.bind) {
|
|
124
|
+
return runtime.makeObject({
|
|
125
|
+
origin: origin,
|
|
126
|
+
bind: "let",
|
|
127
|
+
typ: toPyretType(runtime, expandType(value, shorthands))
|
|
128
|
+
});
|
|
129
|
+
}
|
|
130
|
+
else {
|
|
131
|
+
if(typeof value.origin === "object") {
|
|
132
|
+
origin = value.origin;
|
|
133
|
+
origin.provided = true;
|
|
134
|
+
origin = runtime.makeObject(origin);
|
|
135
|
+
}
|
|
136
|
+
if(value.bind === "let") {
|
|
137
|
+
return runtime.makeObject({
|
|
138
|
+
origin: origin,
|
|
139
|
+
typ: toPyretType(runtime, expandType(value.typ, shorthands)),
|
|
140
|
+
bind: "let"
|
|
141
|
+
});
|
|
142
|
+
}
|
|
143
|
+
else if(value.bind === "alias") {
|
|
144
|
+
return runtime.makeObject({
|
|
145
|
+
'original-name': value["original-name"],
|
|
146
|
+
origin: origin,
|
|
147
|
+
bind: "alias",
|
|
148
|
+
typ: false
|
|
149
|
+
});
|
|
150
|
+
}
|
|
151
|
+
else if(value.bind === "fun") {
|
|
152
|
+
var flatnessInt = parseInt(value.flatness);
|
|
153
|
+
// Flatness had better be (a) an integer and (b) a non-negative number,
|
|
154
|
+
// otherwise treat it as an infinitely-deep function
|
|
155
|
+
var flatness = flatnessInt === value.flatness && flatnessInt >= 0 ? flatnessInt : false;
|
|
156
|
+
return runtime.makeObject({
|
|
157
|
+
origin: origin,
|
|
158
|
+
bind: "fun",
|
|
159
|
+
name: value.name || "",
|
|
160
|
+
flatness: flatness,
|
|
161
|
+
typ: toPyretType(runtime, expandType(value.typ, shorthands))
|
|
162
|
+
});
|
|
163
|
+
}
|
|
164
|
+
else if(value.bind === "var") {
|
|
165
|
+
return runtime.makeObject({
|
|
166
|
+
origin: origin,
|
|
167
|
+
bind: "var",
|
|
168
|
+
typ: toPyretType(runtime, expandType(value.typ, shorthands))
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
else {
|
|
172
|
+
console.error("Bad value provide format:", value);
|
|
173
|
+
throw new Error("Bad value provide format");
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
|
|
179
|
+
function toPyretType(runtime, typ) {
|
|
180
|
+
var O = runtime.makeObject;
|
|
181
|
+
var L = runtime.ffi.makeList;
|
|
182
|
+
var tp = function(thing) { return toPyretType(runtime, thing); };
|
|
183
|
+
function provided(o) { o.provided = true; return O(o); }
|
|
184
|
+
if(typ === "tany") { return O({ tag: "any" }); }
|
|
185
|
+
if(typ === "tbot") { return O({ tag: "bot" }); }
|
|
186
|
+
switch(typ.tag) {
|
|
187
|
+
case "any":
|
|
188
|
+
return O({ tag: "any"});
|
|
189
|
+
case "data-alias":
|
|
190
|
+
return O({ tag: "data-alias", origin: provided(typ.origin), name : typ.name });
|
|
191
|
+
case "data":
|
|
192
|
+
var methods = Object.keys(typ.methods).map(function(k) {
|
|
193
|
+
return O({ name: k, value: tp(typ.methods[k]) });
|
|
194
|
+
});
|
|
195
|
+
var origin;
|
|
196
|
+
if(typeof typ.origin === "object" && typeof typ.origin.provided !== "boolean") { origin = provided(typ.origin); }
|
|
197
|
+
else { origin = O({provided: false}); }
|
|
198
|
+
return O({
|
|
199
|
+
tag: "data",
|
|
200
|
+
origin: origin,
|
|
201
|
+
name: typ.name,
|
|
202
|
+
params: L(typ.params),
|
|
203
|
+
variants: L(typ.variants.map(tp)),
|
|
204
|
+
methods: L(methods)
|
|
205
|
+
});
|
|
206
|
+
case "variant":
|
|
207
|
+
var methods = Object.keys(typ.withmembers).map(function(k) {
|
|
208
|
+
return O({ name: k, value: tp(typ.withmembers[k]) });
|
|
209
|
+
});
|
|
210
|
+
return O({
|
|
211
|
+
tag: "variant",
|
|
212
|
+
name: typ.name,
|
|
213
|
+
vmembers: L(typ.vmembers.map(tp)),
|
|
214
|
+
withmembers: L(methods)
|
|
215
|
+
});
|
|
216
|
+
case "singleton-variant":
|
|
217
|
+
var methods = Object.keys(typ.withmembers).map(function(k) {
|
|
218
|
+
return O({ name: k, value: tp(typ.withmembers[k]) });
|
|
219
|
+
});
|
|
220
|
+
return O({
|
|
221
|
+
tag: "singleton-variant",
|
|
222
|
+
name: typ.name,
|
|
223
|
+
withmembers: L(methods)
|
|
224
|
+
});
|
|
225
|
+
case "variant-member":
|
|
226
|
+
return O({
|
|
227
|
+
tag: "variant-member",
|
|
228
|
+
name: typ.name,
|
|
229
|
+
kind: typ.kind,
|
|
230
|
+
typ: tp(typ.typ),
|
|
231
|
+
});
|
|
232
|
+
case "record":
|
|
233
|
+
return O({
|
|
234
|
+
tag: "record",
|
|
235
|
+
fields: L(Object.keys(typ.fields).map(function(f) { return O({ tag: "member", name: f, value: tp(typ.fields[f]) }); })),
|
|
236
|
+
});
|
|
237
|
+
case "data-refinement":
|
|
238
|
+
return O({
|
|
239
|
+
tag: "data-refinement",
|
|
240
|
+
basetype: tp(typ.basetype),
|
|
241
|
+
variant: typ.variant
|
|
242
|
+
});
|
|
243
|
+
case "name":
|
|
244
|
+
return O({
|
|
245
|
+
tag: "name",
|
|
246
|
+
origin: O(typ.origin),
|
|
247
|
+
name: typ.name
|
|
248
|
+
});
|
|
249
|
+
case "forall":
|
|
250
|
+
return O({
|
|
251
|
+
tag: "forall",
|
|
252
|
+
args: L(typ.args),
|
|
253
|
+
onto: tp(typ.onto)
|
|
254
|
+
});
|
|
255
|
+
case "tyvar":
|
|
256
|
+
return O({
|
|
257
|
+
tag: "tyvar",
|
|
258
|
+
name: typ.name
|
|
259
|
+
});
|
|
260
|
+
case "arrow":
|
|
261
|
+
return O({
|
|
262
|
+
tag: "arrow",
|
|
263
|
+
args: L(typ.args.map(tp)),
|
|
264
|
+
ret: tp(typ.ret)
|
|
265
|
+
});
|
|
266
|
+
case "tuple":
|
|
267
|
+
return O({
|
|
268
|
+
tag: "tuple",
|
|
269
|
+
elts: L(typ.elts.map(tp)),
|
|
270
|
+
});
|
|
271
|
+
case "tyapp":
|
|
272
|
+
return O({
|
|
273
|
+
tag: "tyapp",
|
|
274
|
+
args: L(typ.args.map(tp)),
|
|
275
|
+
onto: tp(typ.onto)
|
|
276
|
+
});
|
|
277
|
+
default:
|
|
278
|
+
console.error(typ);
|
|
279
|
+
throw new Error("No such tag: " + typ.tag);
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
function expandType(typ, shorthands) {
|
|
284
|
+
if(typ.bind == 'fun') {
|
|
285
|
+
return {
|
|
286
|
+
bind: typ.bind,
|
|
287
|
+
origin: typ.origin,
|
|
288
|
+
flatness: typ.flatness,
|
|
289
|
+
name: typ.name,
|
|
290
|
+
typ: expandType(typ.typ, shorthands)
|
|
291
|
+
};
|
|
292
|
+
}
|
|
293
|
+
else if (typ.bind === 'var') {
|
|
294
|
+
return { bind: typ.bind, origin: typ.origin, typ: expandType(typ.typ, shorthands) };
|
|
295
|
+
}
|
|
296
|
+
var fromGlobal = { "import-type": "uri", uri: "builtin://global" };
|
|
297
|
+
var prims = ["Number", "String", "Boolean", "Nothing", "Any"];
|
|
298
|
+
function mkName(origin, name) {
|
|
299
|
+
return { tag: "name", origin: origin, name: name };
|
|
300
|
+
}
|
|
301
|
+
function p(name) { return mkName(fromGlobal, name); }
|
|
302
|
+
function mkApp1(tycon, arg) {
|
|
303
|
+
return {
|
|
304
|
+
tag: "tyapp",
|
|
305
|
+
onto: expandType(tycon, shorthands),
|
|
306
|
+
args: [ expandType(arg, shorthands) ]
|
|
307
|
+
};
|
|
308
|
+
}
|
|
309
|
+
var constrs = {
|
|
310
|
+
"Array": function(name, arg) {
|
|
311
|
+
return mkApp1(mkName({ "import-type": "uri", uri: "builtin://arrays" }, name), arg);
|
|
312
|
+
},
|
|
313
|
+
"RawArray": function(name, arg) { return mkApp1(mkName(fromGlobal, name), arg); },
|
|
314
|
+
"List": function(name, arg) {
|
|
315
|
+
return mkApp1(mkName({ "import-type": "uri", uri: "builtin://lists" }, name), arg);
|
|
316
|
+
},
|
|
317
|
+
"Option": function(name, arg) {
|
|
318
|
+
return mkApp1(mkName({ "import-type": "uri", uri: "builtin://option" }, name), arg);
|
|
319
|
+
},
|
|
320
|
+
"Maker": function(_, arg, ret) {
|
|
321
|
+
var maker = {
|
|
322
|
+
"make": ["arrow", [["RawArray", arg]], ret],
|
|
323
|
+
"make0": ["arrow", [], ret],
|
|
324
|
+
"make1": ["arrow", [arg], ret],
|
|
325
|
+
"make2": ["arrow", [arg, arg], ret],
|
|
326
|
+
"make3": ["arrow", [arg, arg, arg], ret],
|
|
327
|
+
"make4": ["arrow", [arg, arg, arg, arg], ret],
|
|
328
|
+
"make5": ["arrow", [arg, arg, arg, arg, arg], ret]
|
|
329
|
+
};
|
|
330
|
+
return expandType(["record", maker], shorthands);
|
|
331
|
+
}
|
|
332
|
+
};
|
|
333
|
+
var iA = Array.isArray;
|
|
334
|
+
var iO = function(o) { return typeof o === "object" && o !== null && !(iA(o)); };
|
|
335
|
+
|
|
336
|
+
|
|
337
|
+
function expandMember(m, shorthands) {
|
|
338
|
+
if(!iA(m)) {
|
|
339
|
+
throw new Error("Serialized members should be arrays, got: " + String(m));
|
|
340
|
+
}
|
|
341
|
+
if(m.length === 2) {
|
|
342
|
+
return {
|
|
343
|
+
tag: "variant-member",
|
|
344
|
+
kind: "normal",
|
|
345
|
+
name: m[0],
|
|
346
|
+
typ: expandType(m[1], shorthands)
|
|
347
|
+
};
|
|
348
|
+
}
|
|
349
|
+
else if(m.length === 3) {
|
|
350
|
+
return {
|
|
351
|
+
tag: "variant-member",
|
|
352
|
+
kind: "ref",
|
|
353
|
+
name: m[1],
|
|
354
|
+
typ: expandType(m[2], shorthands)
|
|
355
|
+
};
|
|
356
|
+
}
|
|
357
|
+
else {
|
|
358
|
+
throw new Error("Bad serialized member: " + String(m));
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
function expandVariant(v, shorthands) {
|
|
363
|
+
if(!iA(v)) {
|
|
364
|
+
throw new Error("Serialized variant types should be arrays, got: " + String(v));
|
|
365
|
+
}
|
|
366
|
+
else {
|
|
367
|
+
if(v.length === 1) {
|
|
368
|
+
return singletonVariant(v[0], {});
|
|
369
|
+
}
|
|
370
|
+
else if(v.length === 2) {
|
|
371
|
+
if(Array.isArray(v[1])) {
|
|
372
|
+
return variant(v[0], v[1].map(function(m) { return expandMember(m, shorthands); }), {});
|
|
373
|
+
}
|
|
374
|
+
else {
|
|
375
|
+
return singletonVariant(v[0], expandRecord(v[1], shorthands));
|
|
376
|
+
}
|
|
377
|
+
}
|
|
378
|
+
else if(v.length === 3) {
|
|
379
|
+
return variant(v[0],
|
|
380
|
+
v[1].map(function(m) { return expandMember(m, shorthands); }),
|
|
381
|
+
expandRecord(v[2], shorthands));
|
|
382
|
+
}
|
|
383
|
+
else {
|
|
384
|
+
throw new Error("Bad serialized variant: " + String(v));
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
if(typeof typ === "string") {
|
|
390
|
+
if(typ === "tany") {
|
|
391
|
+
return "tany";
|
|
392
|
+
}
|
|
393
|
+
else if(typ === "tbot") {
|
|
394
|
+
return "tbot";
|
|
395
|
+
}
|
|
396
|
+
else if(prims.indexOf(typ) !== -1) {
|
|
397
|
+
return p(typ);
|
|
398
|
+
}
|
|
399
|
+
else if(typ in shorthands) {
|
|
400
|
+
return shorthands[typ];
|
|
401
|
+
}
|
|
402
|
+
else {
|
|
403
|
+
throw new Error("Unknown prim type or shorthand: " + typ);
|
|
404
|
+
}
|
|
405
|
+
}
|
|
406
|
+
else if(Array.isArray(typ)) {
|
|
407
|
+
var head = typ[0];
|
|
408
|
+
if (head in constrs) {
|
|
409
|
+
var constr = constrs[head];
|
|
410
|
+
if(typ.length !== constr.length) {
|
|
411
|
+
throw new Error("Bad tail for type constructor " + head + ": " + String(typ));
|
|
412
|
+
}
|
|
413
|
+
return constr.apply(null, typ);
|
|
414
|
+
}
|
|
415
|
+
else {
|
|
416
|
+
if(head === "arrow" && typ.length === 3 && Array.isArray(typ[1])) {
|
|
417
|
+
return {
|
|
418
|
+
tag: "arrow",
|
|
419
|
+
args: typ[1].map(function(t) { return expandType(t, shorthands); }),
|
|
420
|
+
ret: expandType(typ[2], shorthands)
|
|
421
|
+
};
|
|
422
|
+
}
|
|
423
|
+
else if(head === "tuple" && typ.length === 2 && iA(typ[1])) {
|
|
424
|
+
return {
|
|
425
|
+
tag: "tuple",
|
|
426
|
+
elts: typ[1].map(function(t) { return expandType(t, shorthands); })
|
|
427
|
+
};
|
|
428
|
+
}
|
|
429
|
+
else if(head === "data" && typ.length === 6 && iA(typ[3]) && iA(typ[4]) && iO(typ[5])) {
|
|
430
|
+
return {
|
|
431
|
+
tag: "data",
|
|
432
|
+
origin: typ[1],
|
|
433
|
+
name: typ[2],
|
|
434
|
+
params: typ[3],
|
|
435
|
+
variants: typ[4].map(function(v) { return expandVariant(v, shorthands); }),
|
|
436
|
+
methods: expandRecord(typ[5], shorthands)
|
|
437
|
+
};
|
|
438
|
+
}
|
|
439
|
+
else if(head === "data" && typ.length === 5 && iA(typ[2]) && iA(typ[3]) && iO(typ[4])) {
|
|
440
|
+
return {
|
|
441
|
+
tag: "data",
|
|
442
|
+
origin: {provided: false},
|
|
443
|
+
name: typ[1],
|
|
444
|
+
params: typ[2],
|
|
445
|
+
variants: typ[3].map(function(v) { return expandVariant(v, shorthands); }),
|
|
446
|
+
methods: expandRecord(typ[4], shorthands)
|
|
447
|
+
};
|
|
448
|
+
}
|
|
449
|
+
else if(head === "data-alias" && typ.length === 3) {
|
|
450
|
+
return {
|
|
451
|
+
tag: "data-alias",
|
|
452
|
+
origin: typ[1],
|
|
453
|
+
name: typ[2]
|
|
454
|
+
};
|
|
455
|
+
}
|
|
456
|
+
else if(head === "tid" && typ.length === 2) {
|
|
457
|
+
return {
|
|
458
|
+
tag: "tyvar",
|
|
459
|
+
name: typ[1]
|
|
460
|
+
};
|
|
461
|
+
}
|
|
462
|
+
else if(head === "forall" && typ.length === 3) {
|
|
463
|
+
return {
|
|
464
|
+
tag: "forall",
|
|
465
|
+
args: typ[1],
|
|
466
|
+
onto: expandType(typ[2], shorthands)
|
|
467
|
+
};
|
|
468
|
+
}
|
|
469
|
+
else if(head === "local") {
|
|
470
|
+
return {
|
|
471
|
+
tag: "name",
|
|
472
|
+
origin: {"import-type": "$ELF"},
|
|
473
|
+
name: typ[1]
|
|
474
|
+
};
|
|
475
|
+
}
|
|
476
|
+
else if(head === "record") {
|
|
477
|
+
return {
|
|
478
|
+
tag: "record",
|
|
479
|
+
fields: expandRecord(typ[1], shorthands)
|
|
480
|
+
};
|
|
481
|
+
}
|
|
482
|
+
else if(head === "data%") {
|
|
483
|
+
return {
|
|
484
|
+
tag: "data-refinement",
|
|
485
|
+
basetype: expandType(typ[1], shorthands),
|
|
486
|
+
variant: typ[2]
|
|
487
|
+
};
|
|
488
|
+
}
|
|
489
|
+
else if(head === "tyapp") {
|
|
490
|
+
return {
|
|
491
|
+
tag: "tyapp",
|
|
492
|
+
onto: expandType(typ[1], shorthands),
|
|
493
|
+
args: typ[2].map(function(t) { return expandType(t, shorthands); })
|
|
494
|
+
};
|
|
495
|
+
}
|
|
496
|
+
else {
|
|
497
|
+
throw new Error("Unknown shape or head tag for serialized type: " + String(typ));
|
|
498
|
+
}
|
|
499
|
+
}
|
|
500
|
+
}
|
|
501
|
+
else if(iO(typ)) {
|
|
502
|
+
// If the object a ValueExport, we want to return an object that's
|
|
503
|
+
// exactly the same, but with the typ field expanded.
|
|
504
|
+
if (typ.bind == "fun") {
|
|
505
|
+
var o = {};
|
|
506
|
+
Object.keys(typ).forEach(function(k) {
|
|
507
|
+
if (k == "typ") {
|
|
508
|
+
o[k] = expandType(typ.typ, shorthands);
|
|
509
|
+
}
|
|
510
|
+
else {
|
|
511
|
+
o[k] = typ[k];
|
|
512
|
+
}
|
|
513
|
+
});
|
|
514
|
+
return o;
|
|
515
|
+
}
|
|
516
|
+
return typ;
|
|
517
|
+
}
|
|
518
|
+
else {
|
|
519
|
+
throw new Error("Unknown description for serialized type: " + String(typ));
|
|
520
|
+
}
|
|
521
|
+
}
|
|
522
|
+
|
|
523
|
+
function expandRecord(r, shorthands) {
|
|
524
|
+
var o = {};
|
|
525
|
+
Object.keys(r).forEach(function(k) {
|
|
526
|
+
o[k] = expandType(r[k], shorthands);
|
|
527
|
+
});
|
|
528
|
+
return o;
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
|
|
532
|
+
return {
|
|
533
|
+
any: any,
|
|
534
|
+
string: string,
|
|
535
|
+
number: number,
|
|
536
|
+
boolean: boolean,
|
|
537
|
+
nothing: nothing,
|
|
538
|
+
forall: forall,
|
|
539
|
+
arrow: arrow,
|
|
540
|
+
tyapp: tyapp,
|
|
541
|
+
tyvar: tyvar,
|
|
542
|
+
builtinName: builtinName,
|
|
543
|
+
libName: libName,
|
|
544
|
+
localType: localType,
|
|
545
|
+
record: record,
|
|
546
|
+
dataType: dataType,
|
|
547
|
+
toPyretType: toPyretType,
|
|
548
|
+
bindToPyret: bindToPyret,
|
|
549
|
+
expandType: expandType,
|
|
550
|
+
expandRecord: expandRecord
|
|
551
|
+
};
|
|
552
|
+
|
|
553
|
+
});
|