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
|
import { Ok, Error } from "./gleam.js";
import {
UndefinedType,
ObjectType,
BooleanType,
NumberType,
BigIntType,
StringType,
SymbolType,
FunctionType,
} from "./gleam/javascript.js";
export function toArray(list) {
return list.toArray();
}
export function map(thing, fn) {
return thing.map(fn);
}
export function length(thing) {
return thing.length;
}
export function reduce(thing, acc, fn) {
return thing.reduce(fn, acc);
}
export function reduceRight(thing, acc, fn) {
return thing.reduceRight(fn, acc);
}
export function index(thing, index) {
return index in thing ? new Ok(thing[index]) : new Error(undefined);
}
export function object_from_entries(entries) {
return Object.fromEntries(entries);
}
export function type_of(value) {
switch (typeof value) {
case "undefined":
return new UndefinedType();
case "object":
return new ObjectType();
case "boolean":
return new BooleanType();
case "number":
return new NumberType();
case "bigint":
return new BigIntType();
case "string":
return new StringType();
case "symbol":
return new SymbolType();
case "function":
return new FunctionType();
default:
throw new globalThis.Error(`Unexpected typeof ${typeof value}`);
}
}
export function get_symbol(name) {
return Symbol.for(name);
}
// A wrapper around a promise to prevent `Promise<Promise<T>>` collapsing into
// `Promise<T>`.
class PromiseLayer {
constructor(promise) {
this.promise = promise;
}
static wrap(value) {
return value instanceof Promise ? new PromiseLayer(value) : value;
}
static unwrap(value) {
return value instanceof PromiseLayer ? value.promise : value;
}
}
export function resolve(value) {
return Promise.resolve(PromiseLayer.wrap(value));
}
export function then(promise, fn) {
return promise.then((value) => fn(PromiseLayer.unwrap(value)));
}
export function map_promise(promise, fn) {
return promise.then((value) =>
PromiseLayer.wrap(fn(PromiseLayer.unwrap(value)))
);
}
export function rescue(promise, fn) {
return promise.catch((error) => fn(error));
}
class Reference {
constructor(value) {
this.value = value;
}
}
export function dereference(reference) {
return reference.value;
}
export function make_reference(value) {
return new Reference(value);
}
export function set_reference(ref, value) {
let previous = ref.value;
ref.value = value;
return previous;
}
export function all_promises(...promises) {
return Promise.all(promises);
}
|
