fez-lisp 1.5.138 → 1.5.139

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.
Files changed (2) hide show
  1. package/package.json +1 -1
  2. package/src/check.js +158 -158
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "fez-lisp",
3
3
  "description": "Lisp interpreted & compiled to JavaScript",
4
4
  "author": "AT290690",
5
- "version": "1.5.138",
5
+ "version": "1.5.139",
6
6
  "type": "module",
7
7
  "main": "index.js",
8
8
  "keywords": [
package/src/check.js CHANGED
@@ -225,7 +225,7 @@ export const setReturnToTypeRef = (stats, value) => {
225
225
  export const setStatsRef = (a, b) => (a[STATS] = b[STATS])
226
226
  export const setTypeToReturnRef = (stats, value) => {
227
227
  // To prevent getters overwritting the array subtype
228
- // Change main type if uknown
228
+ // Change main type if unknown
229
229
  if (isUnknownType(stats) || isAnyType(stats))
230
230
  stats[TYPE_PROP][0] = value[RETURNS][0]
231
231
  // cange sub type if it doesn't have
@@ -436,6 +436,15 @@ const retry = (stats, ctx, stack, cb, method = 'prepend') => {
436
436
  stagger(stack, method, ctx, cb)
437
437
  }
438
438
  }
439
+ const once = (stats, ctx, stack, cb, method = 'prepend') => {
440
+ if (
441
+ (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
442
+ !stats.tried
443
+ ) {
444
+ stats.tried = true
445
+ stagger(stack, method, ctx, cb)
446
+ }
447
+ }
439
448
  const retryArgs = (stats, ctx, stack, cb) => {
440
449
  if (stats.counter < MAX_ARGUMENT_RETRY) {
441
450
  stats.counter++
@@ -622,7 +631,7 @@ const resolveGetter = ({ rem, prop, name, env }) => {
622
631
  setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
623
632
  } else if (!isAtom && isCollection) {
624
633
  setPropToReturn(env[name][STATS], env[array[VALUE]][STATS])
625
- }
634
+ } else return false
626
635
  } else return false
627
636
  break
628
637
  case WORD:
@@ -639,7 +648,7 @@ const resolveGetter = ({ rem, prop, name, env }) => {
639
648
  setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
640
649
  } else if (!isAtom && isCollection) {
641
650
  setPropToType(env[name][STATS], env[array[VALUE]][STATS])
642
- }
651
+ } else return false
643
652
  } else return false
644
653
  }
645
654
  break
@@ -1312,190 +1321,181 @@ export const typeCheck = (ast) => {
1312
1321
  getTypes(env[name][STATS])
1313
1322
  )}) (${stringifyArgs(exp)}) (check #202)`
1314
1323
  )
1315
- else {
1316
- // TODO the special form will set type first but it
1317
- // might be known already
1318
- // example
1319
- // (let xs [])
1320
- // (let x (array:set-and-get! xs 0 100))
1321
- // (length x)
1322
-
1323
- // if (
1324
- // isUnknownType(env[name][STATS]) &&
1325
- // !env[name][STATS].tried
1326
- // ) {
1327
- // once(env[name][STATS], stack, () =>
1328
- // check(exp, env, scope)
1329
- // )
1330
- // }
1331
- if (isSpecial)
1332
- setType(env[name][STATS], args[i][STATS])
1333
- }
1334
1324
  }
1335
1325
  break
1336
- case ATOM: {
1337
- if (
1338
- !isUnknownType(args[i][STATS]) &&
1339
- rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0]
1340
- )
1341
- throw new TypeError(
1342
- `Incorrect type of argument (${i}) for (${
1343
- first[VALUE]
1344
- }). Expected (${toTypeNames(
1345
- args[i][STATS][TYPE_PROP][0]
1346
- )}) but got (${toTypeNames(
1347
- rest[i][TYPE]
1348
- )}) (${stringifyArgs(exp)}) (check #2)`
1326
+ case ATOM:
1327
+ {
1328
+ if (
1329
+ !isUnknownType(args[i][STATS]) &&
1330
+ rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0]
1349
1331
  )
1350
- else if (
1351
- hasSubType(args[i][STATS]) &&
1352
- getSubType(args[i][STATS]).has(PREDICATE) &&
1353
- !isAtomABoolean(rest[i][VALUE])
1354
- )
1355
- throw new TypeError(
1356
- `Incorrect type of argument (${i}) for (${
1357
- first[VALUE]
1358
- }). Expected (${formatSubType(
1359
- getTypes(args[i][STATS])
1360
- )}) but got (${
1361
- rest[i][TYPE] === ATOM
1362
- ? toTypeNames(rest[i][TYPE])
1363
- : formatSubType(
1364
- getTypes(env[rest[i][VALUE]][STATS])
1365
- )
1366
- }) (${stringifyArgs(exp)}) (check #203)`
1332
+ throw new TypeError(
1333
+ `Incorrect type of argument (${i}) for (${
1334
+ first[VALUE]
1335
+ }). Expected (${toTypeNames(
1336
+ args[i][STATS][TYPE_PROP][0]
1337
+ )}) but got (${toTypeNames(
1338
+ rest[i][TYPE]
1339
+ )}) (${stringifyArgs(exp)}) (check #2)`
1340
+ )
1341
+ else if (
1342
+ hasSubType(args[i][STATS]) &&
1343
+ getSubType(args[i][STATS]).has(PREDICATE) &&
1344
+ !isAtomABoolean(rest[i][VALUE])
1367
1345
  )
1346
+ throw new TypeError(
1347
+ `Incorrect type of argument (${i}) for (${
1348
+ first[VALUE]
1349
+ }). Expected (${formatSubType(
1350
+ getTypes(args[i][STATS])
1351
+ )}) but got (${
1352
+ rest[i][TYPE] === ATOM
1353
+ ? toTypeNames(rest[i][TYPE])
1354
+ : formatSubType(
1355
+ getTypes(env[rest[i][VALUE]][STATS])
1356
+ )
1357
+ }) (${stringifyArgs(exp)}) (check #203)`
1358
+ )
1359
+ }
1368
1360
  break
1369
- }
1370
- case APPLY: {
1371
- const name = rest[i][VALUE]
1372
- if (!env[name]) continue
1373
- if (
1374
- !isUnknownType(args[i][STATS]) &&
1375
- !isUnknownType(env[name][STATS]) &&
1376
- env[name][STATS][ARG_COUNT] !== VARIADIC
1377
- ) {
1361
+ case APPLY:
1362
+ {
1363
+ const name = rest[i][VALUE]
1364
+ if (!env[name]) continue
1378
1365
  if (
1379
- env[name][STATS][ARG_COUNT] !==
1380
- args[i][STATS][ARG_COUNT]
1366
+ !isUnknownType(args[i][STATS]) &&
1367
+ !isUnknownType(env[name][STATS]) &&
1368
+ env[name][STATS][ARG_COUNT] !== VARIADIC
1381
1369
  ) {
1382
- if (args[i][STATS][ARG_COUNT] === undefined)
1383
- throw new TypeError(
1384
- `Incorrect type for argument of (${
1385
- first[VALUE]
1386
- }) at position (${i}). Expected (${
1387
- STATIC_TYPES.ABSTRACTION
1388
- }) but got (${toTypeNames(
1389
- getType(args[i][STATS])
1390
- )}) (${stringifyArgs(exp)}) (check #111)`
1391
- )
1392
- else if (getType(args[i][STATS]) === APPLY)
1370
+ if (
1371
+ env[name][STATS][ARG_COUNT] !==
1372
+ args[i][STATS][ARG_COUNT]
1373
+ ) {
1374
+ if (args[i][STATS][ARG_COUNT] === undefined)
1375
+ throw new TypeError(
1376
+ `Incorrect type for argument of (${
1377
+ first[VALUE]
1378
+ }) at position (${i}). Expected (${
1379
+ STATIC_TYPES.ABSTRACTION
1380
+ }) but got (${toTypeNames(
1381
+ getType(args[i][STATS])
1382
+ )}) (${stringifyArgs(exp)}) (check #111)`
1383
+ )
1384
+ else if (getType(args[i][STATS]) === APPLY)
1385
+ throw new TypeError(
1386
+ `Incorrect number of arguments for (${
1387
+ args[i][STATS][SIGNATURE]
1388
+ }) the (${
1389
+ KEYWORDS.ANONYMOUS_FUNCTION
1390
+ }) argument of (${
1391
+ first[VALUE]
1392
+ }) at position (${i}). Expected (= ${
1393
+ args[i][STATS][ARG_COUNT]
1394
+ }) but got ${
1395
+ env[name][STATS][ARG_COUNT]
1396
+ } (${stringifyArgs(exp)}) (check #778)`
1397
+ )
1398
+ }
1399
+ }
1400
+ // DEFINED LAMBDAS TYPE CHECKING
1401
+ // #C1
1402
+ // TODO delete this maybe
1403
+ // It will not be possilbe to know return type
1404
+ const match1 = () => {
1405
+ const actual = env[name]
1406
+ const expected = args[i]
1407
+ if (
1408
+ !isUnknownReturn(expected[STATS]) &&
1409
+ !isUnknownReturn(actual[STATS]) &&
1410
+ !equalsReturns(expected[STATS], actual[STATS])
1411
+ ) {
1393
1412
  throw new TypeError(
1394
- `Incorrect number of arguments for (${
1395
- args[i][STATS][SIGNATURE]
1413
+ `Incorrect return type for (${
1414
+ expected[STATS][SIGNATURE]
1396
1415
  }) the (${
1397
1416
  KEYWORDS.ANONYMOUS_FUNCTION
1398
1417
  }) argument of (${
1399
1418
  first[VALUE]
1400
- }) at position (${i}). Expected (= ${
1401
- args[i][STATS][ARG_COUNT]
1402
- }) but got ${
1403
- env[name][STATS][ARG_COUNT]
1404
- } (${stringifyArgs(exp)}) (check #778)`
1405
- )
1406
- }
1407
- }
1408
- // DEFINED LAMBDAS TYPE CHECKING
1409
- // #C1
1410
- // TODO delete this maybe
1411
- // It will not be possilbe to know return type
1412
- const match1 = () => {
1413
- const actual = env[name]
1414
- const expected = args[i]
1415
- if (
1416
- !isUnknownReturn(expected[STATS]) &&
1417
- !isUnknownReturn(actual[STATS]) &&
1418
- !equalsReturns(expected[STATS], actual[STATS])
1419
- ) {
1420
- throw new TypeError(
1421
- `Incorrect return type for (${
1422
- expected[STATS][SIGNATURE]
1423
- }) the (${
1424
- KEYWORDS.ANONYMOUS_FUNCTION
1425
- }) argument of (${
1426
- first[VALUE]
1427
- }) at position (${i}). Expected (${toTypeNames(
1428
- getReturn(expected[STATS])
1429
- )}) but got (${toTypeNames(
1430
- getReturn(actual[STATS])
1431
- )}) (${stringifyArgs(exp)}) (check #782)`
1432
- )
1433
- } else
1434
- retry(actual[STATS], [first, env], stack, match1)
1435
- }
1436
- match1()
1437
- for (
1438
- let j = 0;
1439
- j < args[i][STATS][ARGUMENTS].length;
1440
- ++j
1441
- ) {
1442
- const match2 = () => {
1443
- const actual = env[name][STATS][ARGUMENTS][j]
1444
- const expected = args[i][STATS][ARGUMENTS][j]
1445
- if (
1446
- !isUnknownType(actual[STATS]) &&
1447
- !isUnknownType(expected[STATS]) &&
1448
- !equalsTypes(actual[STATS], expected[STATS])
1449
- )
1450
- throw new TypeError(
1451
- `Incorrect type for (${
1452
- KEYWORDS.ANONYMOUS_FUNCTION
1453
- }) (${
1454
- args[i][STATS][SIGNATURE]
1455
- }) argument at position (${j}) named as (${
1456
- actual[STATS][SIGNATURE]
1457
- }). Expected (${toTypeNames(
1458
- getType(expected[STATS])
1419
+ }) at position (${i}). Expected (${toTypeNames(
1420
+ getReturn(expected[STATS])
1459
1421
  )}) but got (${toTypeNames(
1460
- getType(actual[STATS])
1461
- )}) (${stringifyArgs(exp)}) (check #781)`
1422
+ getReturn(actual[STATS])
1423
+ )}) (${stringifyArgs(exp)}) (check #782)`
1462
1424
  )
1463
- else
1425
+ } else
1464
1426
  retry(
1465
1427
  actual[STATS],
1466
1428
  [first, env],
1467
1429
  stack,
1468
- match2
1430
+ match1
1469
1431
  )
1470
1432
  }
1471
- match2()
1433
+ match1()
1434
+ for (
1435
+ let j = 0;
1436
+ j < args[i][STATS][ARGUMENTS].length;
1437
+ ++j
1438
+ ) {
1439
+ const match2 = () => {
1440
+ const actual = env[name][STATS][ARGUMENTS][j]
1441
+ const expected = args[i][STATS][ARGUMENTS][j]
1442
+ if (
1443
+ !isUnknownType(actual[STATS]) &&
1444
+ !isUnknownType(expected[STATS]) &&
1445
+ !equalsTypes(actual[STATS], expected[STATS])
1446
+ )
1447
+ throw new TypeError(
1448
+ `Incorrect type for (${
1449
+ KEYWORDS.ANONYMOUS_FUNCTION
1450
+ }) (${
1451
+ args[i][STATS][SIGNATURE]
1452
+ }) argument at position (${j}) named as (${
1453
+ actual[STATS][SIGNATURE]
1454
+ }). Expected (${toTypeNames(
1455
+ getType(expected[STATS])
1456
+ )}) but got (${toTypeNames(
1457
+ getType(actual[STATS])
1458
+ )}) (${stringifyArgs(exp)}) (check #781)`
1459
+ )
1460
+ else
1461
+ retry(
1462
+ actual[STATS],
1463
+ [first, env],
1464
+ stack,
1465
+ match2
1466
+ )
1467
+ }
1468
+ match2()
1469
+ }
1472
1470
  }
1473
- }
1471
+ break
1474
1472
  }
1475
- if (!isSpecial) {
1473
+ if (rest[i][TYPE] !== ATOM) {
1476
1474
  const name = rest[i][VALUE]
1477
- if (isUnknownType(args[i][STATS])) {
1478
- retry(args[i][STATS], [first, env], stack, () =>
1479
- check(exp, env, scope)
1480
- )
1481
- }
1482
- // TOODO maybe we don't need this
1475
+ if (!env[name]) return
1476
+ if (
1477
+ // when it's a special form and it's not equal
1478
+ // or failed the boolean subtype case
1479
+ isSpecial &&
1480
+ (!equalsTypes(args[i][STATS], env[name][STATS]) ||
1481
+ !notABooleanType(args[i][STATS], env[name][STATS]))
1482
+ )
1483
+ setType(env[name][STATS], args[i][STATS])
1483
1484
  else if (
1484
- env[name] &&
1485
- !isUnknownType(args[i][STATS]) &&
1486
- isUnknownType(env[name][STATS]) &&
1487
- getType(args[i][STATS]) !== APPLY
1488
- ) {
1489
- // REFF ASSIGMENT
1490
- setTypeRef(env[name][STATS], args[i][STATS])
1491
- } else if (
1492
- env[name] &&
1493
1485
  !isUnknownType(args[i][STATS]) &&
1494
1486
  isUnknownType(env[name][STATS])
1495
1487
  ) {
1496
- setStatsRef(env[rest[i][VALUE]], args[i])
1488
+ // REFF ASSIGMENT
1489
+ if (getType(args[i][STATS]) !== APPLY)
1490
+ setTypeRef(env[name][STATS], args[i][STATS])
1491
+ else setStatsRef(env[rest[i][VALUE]], args[i])
1497
1492
  }
1498
1493
  }
1494
+ if (isUnknownType(args[i][STATS])) {
1495
+ retry(args[i][STATS], [first, env], stack, () =>
1496
+ check(exp, env, scope)
1497
+ )
1498
+ }
1499
1499
  } else {
1500
1500
  const name = rest[i][0][VALUE]
1501
1501
  if (!env[name]) continue