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.
@@ -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
+ });