fez-lisp 1.4.1 → 1.4.3

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.
@@ -17,23 +17,27 @@ export const keywords = {
17
17
  throw new RangeError(
18
18
  `Invalid number of arguments for (${
19
19
  KEYWORDS.ADDITION
20
- }), expected (= 2) but got ${args.length}\n\nat:\n(${
20
+ }), expected (= 2) but got ${args.length}\n\n(${
21
21
  KEYWORDS.ADDITION
22
22
  } ${stringifyArgs(args)})`
23
23
  )
24
24
  const a = evaluate(args[0], env)
25
25
  if (typeof a !== 'number')
26
26
  throw new TypeError(
27
- `First arguments of (${KEYWORDS.ADDITION}) is not a (${
27
+ `First arguments of (${KEYWORDS.ADDITION}) must be a (${
28
28
  RUNTIME_TYPES.NUMBER
29
- })\n\nat:\n(${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
29
+ }) but ${LISP.source(args[0])} is not\n\n(${
30
+ KEYWORDS.ADDITION
31
+ } ${stringifyArgs(args)})`
30
32
  )
31
33
  const b = evaluate(args[1], env)
32
34
  if (typeof b !== 'number')
33
35
  throw new TypeError(
34
- `Second arguments of (${KEYWORDS.ADDITION}) is not a (${
36
+ `Second arguments of (${KEYWORDS.ADDITION}) must be a (${
35
37
  RUNTIME_TYPES.NUMBER
36
- })\n\nat:\n(${KEYWORDS.ADDITION} ${stringifyArgs(args)})`
38
+ }) but ${LISP.source(args[1])} is not\n\n(${
39
+ KEYWORDS.ADDITION
40
+ } ${stringifyArgs(args)})`
37
41
  )
38
42
  return a + b
39
43
  },
@@ -42,23 +46,27 @@ export const keywords = {
42
46
  throw new RangeError(
43
47
  `Invalid number of arguments for (${
44
48
  KEYWORDS.MULTIPLICATION
45
- }), expected (= 2) but got ${args.length}\n\nat:\n(${
49
+ }), expected (= 2) but got ${args.length}\n\n(${
46
50
  KEYWORDS.MULTIPLICATION
47
51
  } ${stringifyArgs(args)})`
48
52
  )
49
53
  const a = evaluate(args[0], env)
50
54
  if (typeof a !== 'number')
51
55
  throw new TypeError(
52
- `First arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
56
+ `First arguments of (${KEYWORDS.MULTIPLICATION}) must be a (${
53
57
  RUNTIME_TYPES.NUMBER
54
- })\n\nat:\n(${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
58
+ }) but ${LISP.source(args[0])} is not\n\n(${
59
+ KEYWORDS.MULTIPLICATION
60
+ } ${stringifyArgs(args)})`
55
61
  )
56
62
  const b = evaluate(args[1], env)
57
63
  if (typeof b !== 'number')
58
64
  throw new TypeError(
59
- `Second arguments of (${KEYWORDS.MULTIPLICATION}) is not a (${
65
+ `Second arguments of (${KEYWORDS.MULTIPLICATION}) must be a (${
60
66
  RUNTIME_TYPES.NUMBER
61
- })\n\nat:\n(${KEYWORDS.MULTIPLICATION} ${stringifyArgs(args)})`
67
+ }) but ${LISP.source(args[1])} is not\n\n(${
68
+ KEYWORDS.MULTIPLICATION
69
+ } ${stringifyArgs(args)})`
62
70
  )
63
71
  return a * b
64
72
  },
@@ -67,24 +75,28 @@ export const keywords = {
67
75
  throw new RangeError(
68
76
  `Invalid number of arguments for (${
69
77
  KEYWORDS.SUBTRACTION
70
- }), expected (or (= 1) (= 2)) but got ${args.length}\n\nat:\n(${
78
+ }), expected (or (= 1) (= 2)) but got ${args.length}\n\n(${
71
79
  KEYWORDS.SUBTRACTION
72
80
  } ${stringifyArgs(args)})`
73
81
  )
74
82
  const a = evaluate(args[0], env)
75
83
  if (typeof a !== 'number')
76
84
  throw new TypeError(
77
- `First argument of (${KEYWORDS.SUBTRACTION}) is not a (${
85
+ `First argument of (${KEYWORDS.SUBTRACTION}) must be a (${
78
86
  RUNTIME_TYPES.NUMBER
79
- })\n\nat:\n(${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
87
+ }) but ${LISP.source(args[0])} is not\n\n(${
88
+ KEYWORDS.SUBTRACTION
89
+ } ${stringifyArgs(args)})`
80
90
  )
81
91
  if (args.length === 1) return -a
82
92
  const b = evaluate(args[1], env)
83
93
  if (typeof b !== 'number')
84
94
  throw new TypeError(
85
- `Second argument of (${KEYWORDS.SUBTRACTION}) is not a (${
95
+ `Second argument of (${KEYWORDS.SUBTRACTION}) must be a (${
86
96
  RUNTIME_TYPES.NUMBER
87
- })\n\nat:\n(${KEYWORDS.SUBTRACTION} ${stringifyArgs(args)})`
97
+ }) but ${LISP.source(args[1])} is not\n\n(${
98
+ KEYWORDS.SUBTRACTION
99
+ } ${stringifyArgs(args)})`
88
100
  )
89
101
  return a - b
90
102
  },
@@ -93,7 +105,7 @@ export const keywords = {
93
105
  throw new RangeError(
94
106
  `Invalid number of arguments for (${
95
107
  KEYWORDS.DIVISION
96
- }), expected (= 2) but got ${args.length}\n\nat:\n(${
108
+ }), expected (= 2) but got ${args.length}\n\n(${
97
109
  KEYWORDS.DIVISION
98
110
  } ${stringifyArgs(args)})`
99
111
  )
@@ -102,22 +114,26 @@ export const keywords = {
102
114
  throw new TypeError(
103
115
  `First argument of (${KEYWORDS.DIVISION}) is not (${
104
116
  RUNTIME_TYPES.NUMBER
105
- })\n\nat:\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
117
+ }) but ${LISP.source(args[0])} is not\n\n(${
118
+ KEYWORDS.DIVISION
119
+ } ${stringifyArgs(args)})`
106
120
  )
107
121
  const b = evaluate(args[1], env)
108
122
  if (typeof b !== 'number')
109
123
  throw new TypeError(
110
124
  `Second argument of (${KEYWORDS.DIVISION}) is not (${
111
125
  RUNTIME_TYPES.NUMBER
112
- })\n\nat:\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
126
+ }) but ${LISP.source(args[1])} is not\n\n(${
127
+ KEYWORDS.DIVISION
128
+ } ${stringifyArgs(args)})`
113
129
  )
114
130
  if (b === 0)
115
131
  throw new TypeError(
116
132
  `Second Argument of (${
117
133
  KEYWORDS.DIVISION
118
- }) can't be a (0) (division by 0 is not allowed)\n\nat:\n(${
119
- KEYWORDS.DIVISION
120
- } ${stringifyArgs(args)})`
134
+ }) can't be a 0 (division by 0 is not allowed) but ${LISP.source(
135
+ args[1]
136
+ )} is 0\n\n(${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
121
137
  )
122
138
  return a / b
123
139
  },
@@ -126,7 +142,7 @@ export const keywords = {
126
142
  throw new RangeError(
127
143
  `Invalid number of arguments for (${
128
144
  KEYWORDS.REMAINDER_OF_DIVISION
129
- }), expected (= 2) but got ${args.length}\n\nat:\n(${
145
+ }), expected (= 2) but got ${args.length}\n\n(${
130
146
  KEYWORDS.REMAINDER_OF_DIVISION
131
147
  } ${stringifyArgs(args)})`
132
148
  )
@@ -135,22 +151,26 @@ export const keywords = {
135
151
  throw new TypeError(
136
152
  `First argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
137
153
  RUNTIME_TYPES.NUMBER
138
- })\n\nat:\n(${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
154
+ }) but ${LISP.source(args[0])} is not\n\n(${
155
+ KEYWORDS.REMAINDER_OF_DIVISION
156
+ } ${stringifyArgs(args)})`
139
157
  )
140
158
  const b = evaluate(args[1], env)
141
159
  if (typeof b !== 'number')
142
160
  throw new TypeError(
143
161
  `Second argument of (${KEYWORDS.REMAINDER_OF_DIVISION}) is not (${
144
162
  RUNTIME_TYPES.NUMBER
145
- })\n\nat:\n(${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
163
+ }) but ${LISP.source(args[1])} is not\n\n(${
164
+ KEYWORDS.REMAINDER_OF_DIVISION
165
+ } ${stringifyArgs(args)})`
146
166
  )
147
167
  if (b === 0)
148
168
  throw new TypeError(
149
169
  `Second argument of (${
150
170
  KEYWORDS.REMAINDER_OF_DIVISION
151
- }) can't be a (0) (division by 0 is not allowed)\n\nat:\n(${
152
- KEYWORDS.REMAINDER_OF_DIVISION
153
- } ${stringifyArgs(args)})`
171
+ }) can't be a 0 (division by 0 is not allowed) but ${LISP.source(
172
+ args[1]
173
+ )} is 0\n\n(${KEYWORDS.REMAINDER_OF_DIVISION} ${stringifyArgs(args)})`
154
174
  )
155
175
 
156
176
  return a % b
@@ -160,23 +180,25 @@ export const keywords = {
160
180
  throw new RangeError(
161
181
  `Invalid number of arguments to (${
162
182
  KEYWORDS.BITWISE_AND
163
- }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(
164
- args
165
- )})`
183
+ }) (= 2 required)\n\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
166
184
  )
167
185
  const a = evaluate(args[0], env)
168
186
  if (typeof a !== 'number')
169
187
  throw new TypeError(
170
- `First arguments of (${KEYWORDS.BITWISE_AND}) is not a (${
188
+ `First arguments of (${KEYWORDS.BITWISE_AND}) must be a (${
171
189
  RUNTIME_TYPES.NUMBER
172
- })\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
190
+ }) but ${LISP.source(args[0])} is not\n\n(${
191
+ KEYWORDS.BITWISE_AND
192
+ } ${stringifyArgs(args)})`
173
193
  )
174
194
  const b = evaluate(args[1], env)
175
195
  if (typeof b !== 'number')
176
196
  throw new TypeError(
177
- `Second arguments of (${KEYWORDS.BITWISE_AND}) is not a (${
197
+ `Second arguments of (${KEYWORDS.BITWISE_AND}) must be a (${
178
198
  RUNTIME_TYPES.NUMBER
179
- })\n\nat:\n(${KEYWORDS.BITWISE_AND} ${stringifyArgs(args)})`
199
+ }) but ${LISP.source(args[1])} is not\n\n(${
200
+ KEYWORDS.BITWISE_AND
201
+ } ${stringifyArgs(args)})`
180
202
  )
181
203
  return a & b
182
204
  },
@@ -185,16 +207,16 @@ export const keywords = {
185
207
  throw new RangeError(
186
208
  `Invalid number of arguments to (${
187
209
  KEYWORDS.BITWISE_NOT
188
- }) (= 1 required)\n\nat:\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(
189
- args
190
- )})`
210
+ }) (= 1 required)\n\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
191
211
  )
192
212
  const operand = evaluate(args[0], env)
193
213
  if (typeof operand !== 'number')
194
214
  throw new TypeError(
195
- `Argument of (${KEYWORDS.BITWISE_NOT}) is not a (${
215
+ `Argument of (${KEYWORDS.BITWISE_NOT}) must be a (${
196
216
  RUNTIME_TYPES.NUMBER
197
- })\n\nat:\n(${KEYWORDS.BITWISE_NOT} ${stringifyArgs(args)})`
217
+ }) but ${LISP.source(args[0])} is not\n\n(${
218
+ KEYWORDS.BITWISE_NOT
219
+ } ${stringifyArgs(args)})`
198
220
  )
199
221
  return ~operand
200
222
  },
@@ -203,17 +225,25 @@ export const keywords = {
203
225
  throw new RangeError(
204
226
  `Invalid number of arguments to (${
205
227
  KEYWORDS.BITWISE_OR
206
- }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(
207
- args
208
- )})`
228
+ }) (= 2 required)\n\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
209
229
  )
210
230
  const a = evaluate(args[0], env)
231
+ if (typeof a !== 'number')
232
+ throw new TypeError(
233
+ `First arguments of (${KEYWORDS.BITWISE_OR}) must be a (${
234
+ RUNTIME_TYPES.NUMBER
235
+ }) but ${LISP.source(args[0])} is not\n\n(${
236
+ KEYWORDS.BITWISE_OR
237
+ } ${stringifyArgs(args)})`
238
+ )
211
239
  const b = evaluate(args[1], env)
212
- if (typeof a !== 'number' || typeof b !== 'number')
240
+ if (typeof b !== 'number')
213
241
  throw new TypeError(
214
- `Not all arguments of (${KEYWORDS.BITWISE_OR}) are (${
242
+ `Second arguments of (${KEYWORDS.BITWISE_OR}) must be a (${
215
243
  RUNTIME_TYPES.NUMBER
216
- })\n\nat:\n(${KEYWORDS.BITWISE_OR} ${stringifyArgs(args)})`
244
+ }) but ${LISP.source(args[1])} is not\n\n(${
245
+ KEYWORDS.BITWISE_OR
246
+ } ${stringifyArgs(args)})`
217
247
  )
218
248
  return a | b
219
249
  },
@@ -222,17 +252,25 @@ export const keywords = {
222
252
  throw new RangeError(
223
253
  `Invalid number of arguments to (${
224
254
  KEYWORDS.BITWISE_XOR
225
- }) (= 2 required)\n\nat:\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(
226
- args
227
- )})`
255
+ }) (= 2 required)\n\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
228
256
  )
229
257
  const a = evaluate(args[0], env)
258
+ if (typeof a !== 'number')
259
+ throw new TypeError(
260
+ `First arguments of (${KEYWORDS.BITWISE_XOR}) must be a (${
261
+ RUNTIME_TYPES.NUMBER
262
+ }) but ${LISP.source(args[0])} is not\n\n(${
263
+ KEYWORDS.BITWISE_XOR
264
+ } ${stringifyArgs(args)})`
265
+ )
230
266
  const b = evaluate(args[1], env)
231
- if (typeof a !== 'number' || typeof b !== 'number')
267
+ if (typeof b !== 'number')
232
268
  throw new TypeError(
233
- `Not all arguments of (${KEYWORDS.BITWISE_XOR}) are (${
269
+ `Second arguments of (${KEYWORDS.BITWISE_XOR}) must be a (${
234
270
  RUNTIME_TYPES.NUMBER
235
- })\n\nat:\n(${KEYWORDS.BITWISE_XOR} ${stringifyArgs(args)})`
271
+ }) but ${LISP.source(args[1])} is not\n\n(${
272
+ KEYWORDS.BITWISE_XOR
273
+ } ${stringifyArgs(args)})`
236
274
  )
237
275
  return a ^ b
238
276
  },
@@ -241,17 +279,27 @@ export const keywords = {
241
279
  throw new RangeError(
242
280
  `Invalid number of arguments to (${
243
281
  KEYWORDS.BITWISE_LEFT_SHIFT
244
- }) (= 2 required)\n\nat:\n(${
282
+ }) (= 2 required)\n\n(${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(
283
+ args
284
+ )})`
285
+ )
286
+ const a = evaluate(args[0], env)
287
+ if (typeof a !== 'number')
288
+ throw new TypeError(
289
+ `First arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) must be a (${
290
+ RUNTIME_TYPES.NUMBER
291
+ }) but ${LISP.source(args[0])} is not\n\n(${
245
292
  KEYWORDS.BITWISE_LEFT_SHIFT
246
293
  } ${stringifyArgs(args)})`
247
294
  )
248
- const a = evaluate(args[0], env)
249
295
  const b = evaluate(args[1], env)
250
- if (typeof a !== 'number' || typeof b !== 'number')
296
+ if (typeof b !== 'number')
251
297
  throw new TypeError(
252
- `Not all arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) are (${
298
+ `Second arguments of (${KEYWORDS.BITWISE_LEFT_SHIFT}) must be a (${
253
299
  RUNTIME_TYPES.NUMBER
254
- })\n\nat:\n(${KEYWORDS.BITWISE_LEFT_SHIFT} ${stringifyArgs(args)})`
300
+ }) but ${LISP.source(args[1])} is not\n\n(${
301
+ KEYWORDS.BITWISE_LEFT_SHIFT
302
+ } ${stringifyArgs(args)})`
255
303
  )
256
304
  return a << b
257
305
  },
@@ -260,17 +308,27 @@ export const keywords = {
260
308
  throw new RangeError(
261
309
  `Invalid number of arguments to (${
262
310
  KEYWORDS.BITWISE_RIGHT_SHIFT
263
- }) (= 2 required)\n\nat:\n(${
311
+ }) (= 2 required)\n\n(${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(
312
+ args
313
+ )})`
314
+ )
315
+ const a = evaluate(args[0], env)
316
+ if (typeof a !== 'number')
317
+ throw new TypeError(
318
+ `First arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) must be a (${
319
+ RUNTIME_TYPES.NUMBER
320
+ }) but ${LISP.source(args[0])} is not\n\n(${
264
321
  KEYWORDS.BITWISE_RIGHT_SHIFT
265
322
  } ${stringifyArgs(args)})`
266
323
  )
267
- const a = evaluate(args[0], env)
268
324
  const b = evaluate(args[1], env)
269
- if (typeof a !== 'number' || typeof b !== 'number')
325
+ if (typeof b !== 'number')
270
326
  throw new TypeError(
271
- `Not all arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) are (${
327
+ `Second arguments of (${KEYWORDS.BITWISE_RIGHT_SHIFT}) must be a (${
272
328
  RUNTIME_TYPES.NUMBER
273
- })\n\nat:\n(${KEYWORDS.BITWISE_RIGHT_SHIFT} ${stringifyArgs(args)})`
329
+ }) but ${LISP.source(args[1])} is not\n\n(${
330
+ KEYWORDS.BITWISE_RIGHT_SHIFT
331
+ } ${stringifyArgs(args)})`
274
332
  )
275
333
  return a >> b
276
334
  },
@@ -279,17 +337,29 @@ export const keywords = {
279
337
  throw new RangeError(
280
338
  `Invalid number of arguments to (${
281
339
  KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
282
- }) (= 2 required)\n\nat:\n(${
340
+ }) (= 2 required)\n\n(${
283
341
  KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
284
342
  } ${stringifyArgs(args)})`
285
343
  )
286
344
  const a = evaluate(args[0], env)
345
+ if (typeof a !== 'number')
346
+ throw new TypeError(
347
+ `First arguments of (${
348
+ KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
349
+ }) must be a (${RUNTIME_TYPES.NUMBER}) but ${LISP.source(
350
+ args[0]
351
+ )} is not\n\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
352
+ args
353
+ )})`
354
+ )
287
355
  const b = evaluate(args[1], env)
288
- if (typeof a !== 'number' || typeof b !== 'number')
356
+ if (typeof b !== 'number')
289
357
  throw new TypeError(
290
- `Not all arguments of (${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT}) are (${
291
- RUNTIME_TYPES.NUMBER
292
- })\n\nat:\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
358
+ `Second arguments of (${
359
+ KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT
360
+ }) must be a (${RUNTIME_TYPES.NUMBER}) but ${LISP.source(
361
+ args[1]
362
+ )} is not\n\n(${KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT} ${stringifyArgs(
293
363
  args
294
364
  )})`
295
365
  )
@@ -303,22 +373,20 @@ export const keywords = {
303
373
  throw new RangeError(
304
374
  `Invalid number of arguments for (${
305
375
  KEYWORDS.GET_ARRAY
306
- }) (= 2 required)\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(
307
- args
308
- )})`
376
+ }) (= 2 required)\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
309
377
  )
310
378
  const array = evaluate(args[0], env)
311
379
  if (!Array.isArray(array))
312
380
  throw new TypeError(
313
381
  `First argument of (${KEYWORDS.GET_ARRAY}) must be an (${
314
382
  RUNTIME_TYPES.ARRAY
315
- })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
383
+ })\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
316
384
  )
317
385
  if (array.length === 0)
318
386
  throw new RangeError(
319
387
  `First argument of (${KEYWORDS.GET_ARRAY}) is an empty (${
320
388
  RUNTIME_TYPES.ARRAY
321
- })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
389
+ })\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
322
390
  )
323
391
  const index = evaluate(args[1], env)
324
392
  if (!Number.isInteger(index) || index < 0)
@@ -327,9 +395,7 @@ export const keywords = {
327
395
  KEYWORDS.GET_ARRAY
328
396
  }) must be a positive (32 bit ${
329
397
  RUNTIME_TYPES.NUMBER
330
- }) (= i ${index})\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(
331
- args
332
- )})`
398
+ }) (= i ${index})\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
333
399
  )
334
400
  if (index > array.length - 1)
335
401
  throw new RangeError(
@@ -337,14 +403,14 @@ export const keywords = {
337
403
  RUNTIME_TYPES.ARRAY
338
404
  }) bounds (= i ${index}) expected (and (>= i 0) (< i ${
339
405
  array.length
340
- }))\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
406
+ }))\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
341
407
  )
342
408
  const value = array.at(index)
343
409
  if (value == undefined)
344
410
  throw new RangeError(
345
411
  `Trying to get a null value in (${RUNTIME_TYPES.ARRAY}) at (${
346
412
  KEYWORDS.GET_ARRAY
347
- })\n\nat:\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
413
+ })\n\n(${KEYWORDS.GET_ARRAY} ${stringifyArgs(args)})`
348
414
  )
349
415
  return value
350
416
  },
@@ -353,18 +419,16 @@ export const keywords = {
353
419
  throw new RangeError(
354
420
  `Invalid number of arguments for (${
355
421
  KEYWORDS.SET_ARRAY
356
- }) (or 1 3) required\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(
357
- args
358
- )})`
422
+ }) (or 1 3) required\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
359
423
  )
360
424
  const array = evaluate(args[0], env)
361
425
  if (!Array.isArray(array))
362
426
  throw new TypeError(
363
427
  `First argument of (${KEYWORDS.SET_ARRAY}) must be an (${
364
428
  RUNTIME_TYPES.ARRAY
365
- }) but got (${array})\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(
366
- args
367
- )})`
429
+ }) but ${LISP.source(args[0])} is not\n\n(${
430
+ KEYWORDS.SET_ARRAY
431
+ } ${stringifyArgs(args)})`
368
432
  )
369
433
  if (args.length === 1) {
370
434
  array.pop()
@@ -374,7 +438,7 @@ export const keywords = {
374
438
  throw new TypeError(
375
439
  `Second argument of (${KEYWORDS.SET_ARRAY}) must be a positive (${
376
440
  RUNTIME_TYPES.NUMBER
377
- } integer) (= i ${index})\n\nat:\n(${
441
+ } integer) (= i ${index}) but ${LISP.source(args[1])} is not\n\n(${
378
442
  KEYWORDS.SET_ARRAY
379
443
  } ${stringifyArgs(args)})`
380
444
  )
@@ -384,14 +448,16 @@ export const keywords = {
384
448
  RUNTIME_TYPES.ARRAY
385
449
  }) bounds (${index}) expected (and (>= i 0) (< i ${
386
450
  array.length
387
- }))\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
451
+ })) but ${LISP.source(args[1])} is not\n\n(${
452
+ KEYWORDS.SET_ARRAY
453
+ } ${stringifyArgs(args)})`
388
454
  )
389
455
  const value = evaluate(args[2], env)
390
456
  if (value == undefined)
391
457
  throw new RangeError(
392
458
  `Trying to set a null value in (${RUNTIME_TYPES.ARRAY}) at (${
393
459
  KEYWORDS.SET_ARRAY
394
- })\n\nat:\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
460
+ })\n\n(${KEYWORDS.SET_ARRAY} ${stringifyArgs(args)})`
395
461
  )
396
462
  array[index] = value
397
463
  }
@@ -402,16 +468,16 @@ export const keywords = {
402
468
  throw new RangeError(
403
469
  `Invalid number of arguments for (${
404
470
  KEYWORDS.ARRAY_LENGTH
405
- }) (= 1 required)\n\nat:\n(${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(
406
- args
407
- )})`
471
+ }) (= 1 required)\n\n(${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
408
472
  )
409
473
  const array = evaluate(args[0], env)
410
474
  if (!Array.isArray(array))
411
475
  throw new TypeError(
412
476
  `First argument of (${KEYWORDS.ARRAY_LENGTH}) must be an ${
413
477
  RUNTIME_TYPES.ARRAY
414
- }\n\nat:\n(${KEYWORDS.ARRAY_LENGTH} ${stringifyArgs(args)})`
478
+ } but ${LISP.source(args[0])} is not\n\n(${
479
+ KEYWORDS.ARRAY_LENGTH
480
+ } ${stringifyArgs(args)})`
415
481
  )
416
482
  return array.length
417
483
  },
@@ -420,7 +486,7 @@ export const keywords = {
420
486
  throw new RangeError(
421
487
  `Invalid number of arguments for (${
422
488
  KEYWORDS.IF
423
- }), expected (or (= 3) (= 2)) but got ${args.length}\n\nat:\n(${
489
+ }), expected (or (= 3) (= 2)) but got ${args.length}\n\n(${
424
490
  KEYWORDS.IF
425
491
  } ${stringifyArgs(args)})`
426
492
  )
@@ -429,9 +495,9 @@ export const keywords = {
429
495
  throw new TypeError(
430
496
  `Condition of (${
431
497
  KEYWORDS.IF
432
- }) must be ${TRUE} or ${FALSE} but got ${LISP.source(
433
- args[0]
434
- )}\n\nat:\n(${KEYWORDS.IF} ${stringifyArgs(args)})`
498
+ }) must be ${TRUE} or ${FALSE} but ${LISP.source(args[0])} is not\n\n(${
499
+ KEYWORDS.IF
500
+ } ${stringifyArgs(args)})`
435
501
  )
436
502
  return condition
437
503
  ? evaluate(args[1], env)
@@ -442,18 +508,18 @@ export const keywords = {
442
508
  [KEYWORDS.NOT]: (args, env) => {
443
509
  if (args.length !== 1)
444
510
  throw new RangeError(
445
- `Invalid number of arguments for (${
511
+ `Invalid number of arguments for (${KEYWORDS.NOT}) (= 1 required)\n\n(${
446
512
  KEYWORDS.NOT
447
- }) (= 1 required)\n\nat:\n(${KEYWORDS.NOT} ${stringifyArgs(args)})`
513
+ } ${stringifyArgs(args)})`
448
514
  )
449
515
  const operand = evaluate(args[0], env)
450
516
  if (operand !== FALSE && operand !== TRUE)
451
517
  throw new TypeError(
452
518
  `Condition of (${
453
519
  KEYWORDS.NOT
454
- }) must be ${TRUE} or ${FALSE} but got ${LISP.source(
455
- args[0]
456
- )}\n\nat:\n(${KEYWORDS.NOT} ${stringifyArgs(args)})`
520
+ }) must be ${TRUE} or ${FALSE} but ${LISP.source(args[0])} is not\n\n(${
521
+ KEYWORDS.NOT
522
+ } ${stringifyArgs(args)})`
457
523
  )
458
524
  return +!evaluate(args[0], env)
459
525
  },
@@ -462,21 +528,25 @@ export const keywords = {
462
528
  throw new RangeError(
463
529
  `Invalid number of arguments for (${
464
530
  KEYWORDS.EQUAL
465
- }) (= 2 required)\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
531
+ }) (= 2 required)\n\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
466
532
  )
467
533
  const a = evaluate(args[0], env)
468
534
  const b = evaluate(args[1], env)
469
535
  if (typeof a !== 'number')
470
536
  throw new TypeError(
471
- `Invalid use of (${KEYWORDS.EQUAL}), first argument is not an ${
537
+ `First argument of (${KEYWORDS.EQUAL}) must be a ${
472
538
  RUNTIME_TYPES.NUMBER
473
- }\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
539
+ } but ${LISP.source(args[0])} is not\n\n(${
540
+ KEYWORDS.EQUAL
541
+ } ${stringifyArgs(args)})`
474
542
  )
475
543
  if (typeof b !== 'number')
476
544
  throw new TypeError(
477
- `Invalid use of (${KEYWORDS.EQUAL}), second argument are not an ${
545
+ `Second argument of (${KEYWORDS.EQUAL}) must be a ${
478
546
  RUNTIME_TYPES.NUMBER
479
- }\n\nat:\n(${KEYWORDS.EQUAL} ${stringifyArgs(args)})`
547
+ } but ${LISP.source(args[1])} is not\n\n(${
548
+ KEYWORDS.EQUAL
549
+ } ${stringifyArgs(args)})`
480
550
  )
481
551
  return +(a === b)
482
552
  },
@@ -485,23 +555,25 @@ export const keywords = {
485
555
  throw new RangeError(
486
556
  `Invalid number of arguments for (${
487
557
  KEYWORDS.LESS_THAN
488
- }) (= 2 required)\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(
489
- args
490
- )})`
558
+ }) (= 2 required)\n\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
491
559
  )
492
560
  const a = evaluate(args[0], env)
493
561
  const b = evaluate(args[1], env)
494
562
  if (typeof a !== 'number')
495
563
  throw new TypeError(
496
- `Invalid use of (${KEYWORDS.LESS_THAN}), first argument is not an ${
564
+ `First argument of (${KEYWORDS.LESS_THAN}) must be a ${
497
565
  RUNTIME_TYPES.NUMBER
498
- }\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
566
+ } but ${LISP.source(args[0])} is not\n\n(${
567
+ KEYWORDS.LESS_THAN
568
+ } ${stringifyArgs(args)})`
499
569
  )
500
570
  if (typeof b !== 'number')
501
571
  throw new TypeError(
502
- `Invalid use of (${KEYWORDS.LESS_THAN}), second argument are not an ${
572
+ `Second argument of (${KEYWORDS.LESS_THAN}) must be a ${
503
573
  RUNTIME_TYPES.NUMBER
504
- }\n\nat:\n(${KEYWORDS.LESS_THAN} ${stringifyArgs(args)})`
574
+ } but ${LISP.source(args[1])} is not\n\n(${
575
+ KEYWORDS.LESS_THAN
576
+ } ${stringifyArgs(args)})`
505
577
  )
506
578
  return +(a < b)
507
579
  },
@@ -510,23 +582,23 @@ export const keywords = {
510
582
  throw new RangeError(
511
583
  `Invalid number of arguments for (${
512
584
  KEYWORDS.GREATHER_THAN
513
- }) (= 2 required)\n\nat:\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(
514
- args
515
- )})`
585
+ }) (= 2 required)\n\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
516
586
  )
517
587
  const a = evaluate(args[0], env)
518
588
  const b = evaluate(args[1], env)
519
589
  if (typeof a !== 'number')
520
590
  throw new TypeError(
521
- `Invalid use of (${KEYWORDS.GREATHER_THAN}), first argument is not an ${
591
+ `First argument of (${KEYWORDS.GREATHER_THAN}) must be a ${
522
592
  RUNTIME_TYPES.NUMBER
523
- }\n\nat:\n(${KEYWORDS.GREATHER_THAN} ${stringifyArgs(args)})`
593
+ } but ${LISP.source(args[0])} is not\n\n(${
594
+ KEYWORDS.GREATHER_THAN
595
+ } ${stringifyArgs(args)})`
524
596
  )
525
597
  if (typeof b !== 'number')
526
598
  throw new TypeError(
527
- `Invalid use of (${
528
- KEYWORDS.GREATHER_THAN
529
- }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
599
+ `Second argument of (${KEYWORDS.GREATHER_THAN}) must be a ${
600
+ RUNTIME_TYPES.NUMBER
601
+ } but ${LISP.source(args[1])} is not\n\n(${
530
602
  KEYWORDS.GREATHER_THAN
531
603
  } ${stringifyArgs(args)})`
532
604
  )
@@ -537,7 +609,7 @@ export const keywords = {
537
609
  throw new RangeError(
538
610
  `Invalid number of arguments for (${
539
611
  KEYWORDS.GREATHER_THAN_OR_EQUAL
540
- }) (= 2 required)\n\nat:\n(${
612
+ }) (= 2 required)\n\n(${
541
613
  KEYWORDS.GREATHER_THAN_OR_EQUAL
542
614
  } ${stringifyArgs(args)})`
543
615
  )
@@ -545,17 +617,17 @@ export const keywords = {
545
617
  const b = evaluate(args[1], env)
546
618
  if (typeof a !== 'number')
547
619
  throw new TypeError(
548
- `Invalid use of (${
549
- KEYWORDS.GREATHER_THAN_OR_EQUAL
550
- }), first argument is not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
620
+ `First argument of (${KEYWORDS.GREATHER_THAN_OR_EQUAL}) must be a ${
621
+ RUNTIME_TYPES.NUMBER
622
+ } but ${LISP.source(args[0])} is not\n\n(${
551
623
  KEYWORDS.GREATHER_THAN_OR_EQUAL
552
624
  } ${stringifyArgs(args)})`
553
625
  )
554
626
  if (typeof b !== 'number')
555
627
  throw new TypeError(
556
- `Invalid use of (${
557
- KEYWORDS.GREATHER_THAN_OR_EQUAL
558
- }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
628
+ `Second argument of (${KEYWORDS.GREATHER_THAN_OR_EQUAL}) must be a ${
629
+ RUNTIME_TYPES.NUMBER
630
+ } but ${LISP.source(args[1])} is not\n\n(${
559
631
  KEYWORDS.GREATHER_THAN_OR_EQUAL
560
632
  } ${stringifyArgs(args)})`
561
633
  )
@@ -566,25 +638,25 @@ export const keywords = {
566
638
  throw new RangeError(
567
639
  `Invalid number of arguments for (${
568
640
  KEYWORDS.LESS_THAN_OR_EQUAL
569
- }) (= 2 required)\n\nat:\n(${
570
- KEYWORDS.LESS_THAN_OR_EQUAL
571
- } ${stringifyArgs(args)})`
641
+ }) (= 2 required)\n\n(${KEYWORDS.LESS_THAN_OR_EQUAL} ${stringifyArgs(
642
+ args
643
+ )})`
572
644
  )
573
645
  const a = evaluate(args[0], env)
574
646
  const b = evaluate(args[1], env)
575
647
  if (typeof a !== 'number')
576
648
  throw new TypeError(
577
- `Invalid use of (${
578
- KEYWORDS.LESS_THAN_OR_EQUAL
579
- }), first argument is not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
649
+ `First argument of (${KEYWORDS.LESS_THAN_OR_EQUAL}) must be a ${
650
+ RUNTIME_TYPES.NUMBER
651
+ } but ${LISP.source(args[0])} is not\n\n(${
580
652
  KEYWORDS.LESS_THAN_OR_EQUAL
581
653
  } ${stringifyArgs(args)})`
582
654
  )
583
655
  if (typeof b !== 'number')
584
656
  throw new TypeError(
585
- `Invalid use of (${
586
- KEYWORDS.LESS_THAN_OR_EQUAL
587
- }), second argument are not an ${RUNTIME_TYPES.NUMBER}\n\nat:\n(${
657
+ `Second argument of (${KEYWORDS.LESS_THAN_OR_EQUAL}) must be a ${
658
+ RUNTIME_TYPES.NUMBER
659
+ } but ${LISP.source(args[1])} is not\n\n(${
588
660
  KEYWORDS.LESS_THAN_OR_EQUAL
589
661
  } ${stringifyArgs(args)})`
590
662
  )
@@ -593,16 +665,16 @@ export const keywords = {
593
665
  [KEYWORDS.AND]: (args, env) => {
594
666
  if (args.length !== 2)
595
667
  throw new RangeError(
596
- `Invalid number of arguments for (${
668
+ `Invalid number of arguments for (${KEYWORDS.AND}) (= 2 required)\n\n(${
597
669
  KEYWORDS.AND
598
- }) (= 2 required)\n\nat:\n(${KEYWORDS.AND} ${stringifyArgs(args)})`
670
+ } ${stringifyArgs(args)})`
599
671
  )
600
672
  const a = evaluate(args[0], env)
601
673
  if (a !== FALSE && a !== TRUE)
602
674
  throw new TypeError(
603
675
  `Condition of (${
604
676
  KEYWORDS.AND
605
- }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
677
+ }) must be ${TRUE} or ${FALSE} but got\n\n(${
606
678
  KEYWORDS.AND
607
679
  } ${stringifyArgs(args)})`
608
680
  )
@@ -612,7 +684,7 @@ export const keywords = {
612
684
  throw new TypeError(
613
685
  `Condition of (${
614
686
  KEYWORDS.AND
615
- }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
687
+ }) must be ${TRUE} or ${FALSE} but got\n\n(${
616
688
  KEYWORDS.AND
617
689
  } ${stringifyArgs(args)})`
618
690
  )
@@ -621,16 +693,16 @@ export const keywords = {
621
693
  [KEYWORDS.OR]: (args, env) => {
622
694
  if (args.length !== 2)
623
695
  throw new RangeError(
624
- `Invalid number of arguments for (${
696
+ `Invalid number of arguments for (${KEYWORDS.OR}) (= 2 required)\n\n(${
625
697
  KEYWORDS.OR
626
- }) (= 2 required)\n\nat:\n(${KEYWORDS.OR} ${stringifyArgs(args)})`
698
+ } ${stringifyArgs(args)})`
627
699
  )
628
700
  const a = evaluate(args[0], env)
629
701
  if (a !== FALSE && a !== TRUE)
630
702
  throw new TypeError(
631
703
  `Condition of (${
632
704
  KEYWORDS.OR
633
- }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
705
+ }) must be ${TRUE} or ${FALSE} but got\n\n(${
634
706
  KEYWORDS.OR
635
707
  } ${stringifyArgs(args)})`
636
708
  )
@@ -640,7 +712,7 @@ export const keywords = {
640
712
  throw new TypeError(
641
713
  `Condition of (${
642
714
  KEYWORDS.OR
643
- }) must be ${TRUE} or ${FALSE} but got\n\nat:\n(${
715
+ }) must be ${TRUE} or ${FALSE} but got\n\n(${
644
716
  KEYWORDS.OR
645
717
  } ${stringifyArgs(args)})`
646
718
  )
@@ -651,7 +723,7 @@ export const keywords = {
651
723
  throw new RangeError(
652
724
  `Invalid number of arguments to (${
653
725
  KEYWORDS.DEFINE_VARIABLE
654
- }) (= 2 required)\n\nat:\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(
726
+ }) (= 2 required)\n\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(
655
727
  args
656
728
  )})`
657
729
  )
@@ -662,11 +734,11 @@ export const keywords = {
662
734
  throw new SyntaxError(
663
735
  `First argument of (${KEYWORDS.DEFINE_VARIABLE}) must be word but got ${
664
736
  TYPES[type]
665
- }\n\nat:\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
737
+ }\n\n(${KEYWORDS.DEFINE_VARIABLE} ${stringifyArgs(args)})`
666
738
  )
667
739
  else if (isForbiddenVariableName(name))
668
740
  throw new ReferenceError(
669
- `Variable name ${name} is forbidden at\n\nat:\n(${
741
+ `Variable name ${name} is forbidden \n\n(${
670
742
  KEYWORDS.DEFINE_VARIABLE
671
743
  } ${stringifyArgs(args)})`
672
744
  )
@@ -686,7 +758,7 @@ export const keywords = {
686
758
  name ? ` ${name}` : ''
687
759
  }) are provided (expects ${params.length} but got ${
688
760
  props.length
689
- })\n\nat:\n(${KEYWORDS.ANONYMOUS_FUNCTION} ${stringifyArgs(params)})`
761
+ })\n\n(${KEYWORDS.ANONYMOUS_FUNCTION} ${stringifyArgs(params)})`
690
762
  )
691
763
  const localEnv = Object.create(env)
692
764
  // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
@@ -706,7 +778,7 @@ export const keywords = {
706
778
  throw new RangeError(
707
779
  `Invalid number of arguments to (${
708
780
  KEYWORDS.CALL_FUNCTION
709
- }) (>= 1 required)\n\nat:\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(
781
+ }) (>= 1 required)\n\n(${KEYWORDS.CALL_FUNCTION} ${stringifyArgs(
710
782
  args
711
783
  )})`
712
784
  )
@@ -715,7 +787,7 @@ export const keywords = {
715
787
  throw new TypeError(
716
788
  `Preceeding arguments of (${
717
789
  KEYWORDS.CALL_FUNCTION
718
- }) must not be an reserved word\n\nat:\n(${
790
+ }) must not be an reserved word\n\n(${
719
791
  KEYWORDS.CALL_FUNCTION
720
792
  } ${stringifyArgs(args)})`
721
793
  )
@@ -724,7 +796,7 @@ export const keywords = {
724
796
  throw new TypeError(
725
797
  `Last argument of (${KEYWORDS.CALL_FUNCTION}) must be a (${
726
798
  KEYWORDS.ANONYMOUS_FUNCTION
727
- }) but got ${LISP.stringify(apply)}\n\nat:\n(${
799
+ }) but got ${LISP.stringify(apply)}\n\n(${
728
800
  KEYWORDS.CALL_FUNCTION
729
801
  } ${stringifyArgs(args)})`
730
802
  )
@@ -736,7 +808,7 @@ export const keywords = {
736
808
  throw new RangeError(
737
809
  `Invalid number of arguments to (${
738
810
  KEYWORDS.BLOCK
739
- }) (>= 1 required)\n\nat:\n(${KEYWORDS.BLOCK} ${stringifyArgs(args)})`
811
+ }) (>= 1 required)\n\n(${KEYWORDS.BLOCK} ${stringifyArgs(args)})`
740
812
  )
741
813
  return args.reduce((_, x) => evaluate(x, env), FALSE)
742
814
  },
@@ -745,7 +817,7 @@ export const keywords = {
745
817
  throw new RangeError(
746
818
  `Invalid number of arguments for (${
747
819
  KEYWORDS.IS_ATOM
748
- }) (= 1 required)\n\nat:\n(${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
820
+ }) (= 1 required)\n\n(${KEYWORDS.IS_ATOM} ${stringifyArgs(args)})`
749
821
  )
750
822
  return +(typeof evaluate(args[0], env) === 'number')
751
823
  },
@@ -754,10 +826,24 @@ export const keywords = {
754
826
  throw new RangeError(
755
827
  `Invalid number of arguments for (${
756
828
  KEYWORDS.IS_LAMBDA
757
- }) (= 1 required)\n\nat:\n(${KEYWORDS.IS_LAMBDA} ${stringifyArgs(
758
- args
759
- )})`
829
+ }) (= 1 required)\n\n(${KEYWORDS.IS_LAMBDA} ${stringifyArgs(args)})`
760
830
  )
761
831
  return +(typeof evaluate(args[0], env) === 'function')
832
+ },
833
+ [KEYWORDS.ERROR]: (args, env) => {
834
+ if (args.length !== 1)
835
+ throw new RangeError(
836
+ `Invalid number of arguments to (${KEYWORDS.ERROR}) (= 1 required) (${
837
+ KEYWORDS.ERROR
838
+ } ${stringifyArgs(args)})`
839
+ )
840
+ const expression = evaluate(args[0], env)
841
+ if (!Array.isArray(expression))
842
+ throw new TypeError(
843
+ `Argument of (${KEYWORDS.ERROR}) must be an (${
844
+ KEYWORDS.ARRAY_TYPE
845
+ }) but got (${expression}) (${KEYWORDS.ERROR} ${stringifyArgs(args)})`
846
+ )
847
+ throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
762
848
  }
763
849
  }