fez-lisp 1.6.77 → 1.6.80

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 (8) hide show
  1. package/index.js +14 -2
  2. package/lib/baked/std-T.js +1 -1
  3. package/lib/baked/std.js +1 -1
  4. package/package.json +1 -1
  5. package/src/check.js +267 -156
  6. package/src/debugger.js +32 -6
  7. package/src/types.js +35 -11
  8. package/src/utils.js +78 -35
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.6.77",
5
+ "version": "1.6.80",
6
6
  "type": "module",
7
7
  "main": "index.js",
8
8
  "keywords": [
package/src/check.js CHANGED
@@ -46,7 +46,8 @@ import {
46
46
  NUMBER,
47
47
  NUMBER_SUBTYPE,
48
48
  SubType,
49
- GET_ARRAY_INFERENCE_SET
49
+ GET_ARRAY_INFERENCE_SET,
50
+ GENERIC
50
51
  } from './types.js'
51
52
  import {
52
53
  Brr,
@@ -104,7 +105,11 @@ export const castReturn = (stats, type) => {
104
105
  type[RETURNS][1] && (stats[RETURNS][1] = type[RETURNS][1])
105
106
  )
106
107
  }
107
- export const isGenericReturn = (stats) => stats[RETURNS].length === 3
108
+ export const isGenericReturn = (stats) =>
109
+ stats[RETURNS].length === 3 && stats[RETURNS][2][0] !== -1
110
+ export const isGenericType = (stats) =>
111
+ stats[TYPE_PROP].length === 3 && stats[TYPE_PROP][2][0] !== -1
112
+
108
113
  export const isTypeAbstraction = (stats) => stats[TYPE_PROP] === APPLY
109
114
  export const setPropToAtom = (stats, prop) => {
110
115
  return (
@@ -113,7 +118,7 @@ export const setPropToAtom = (stats, prop) => {
113
118
  )
114
119
  }
115
120
  const setReturnToGeneric = (stats, index) => {
116
- stats[RETURNS] = [UNKNOWN, undefined, index]
121
+ stats[RETURNS] = [UNKNOWN, undefined, [index, 1]]
117
122
  }
118
123
  export const setPropToPredicate = (stats, prop) => {
119
124
  return (stats[prop][1] = BOOLEAN_SUBTYPE())
@@ -275,9 +280,8 @@ export const setReturnToType = (stats, value) =>
275
280
  export const isAnyReturn = (stats) => stats && stats[RETURNS][0] === ANY
276
281
  export const isAnyType = (stats) => stats && stats[TYPE_PROP][0] === ANY
277
282
  export const isUnknownType = (stats) => stats && stats[TYPE_PROP][0] === UNKNOWN
278
- export const isUnknownProp = (stats, prop) => {
279
- return stats && stats[prop][0] === UNKNOWN
280
- }
283
+ export const isUnknownProp = (stats, prop) =>
284
+ stats && stats[prop][0] === UNKNOWN
281
285
  export const isSubType = (subtype) => subtype instanceof SubType
282
286
  export const isSubTypeUknown = (subtype) =>
283
287
  subtype.size === 1 && subtype.has(UNKNOWN)
@@ -960,18 +964,18 @@ const resolveReturnType = ({
960
964
  else
961
965
  once(env[name][STATS], exp, stack, () => {
962
966
  setPropToTypeRef(env[name][STATS], prop, env[returns[VALUE]][STATS])
963
- if (isUnknownProp(env[name][STATS], prop)) {
964
- // TODO: DRY
965
- const index = env[name][STATS][ARGUMENTS]
966
- ? env[name][STATS][ARGUMENTS].findIndex(
967
- (x) => x[STATS][SIGNATURE] === returns[VALUE]
968
- )
969
- : -1
970
- if (index >= 0) {
971
- setReturnToGeneric(env[name][STATS], index)
972
- return true
973
- } else if (!env[returns[VALUE]]) return false
974
- }
967
+ // if (isUnknownProp(env[name][STATS], prop)) {
968
+ // // TODO: DRY
969
+ // const index = env[name][STATS][ARGUMENTS]
970
+ // ? env[name][STATS][ARGUMENTS].findIndex(
971
+ // (x) => x[STATS][SIGNATURE] === returns[VALUE]
972
+ // )
973
+ // : -1
974
+ // if (index >= 0) {
975
+ // setReturnToGeneric(env[name][STATS], index)
976
+ // return true
977
+ // } else if (!env[returns[VALUE]]) return false
978
+ // }
975
979
  })
976
980
  }
977
981
  } else {
@@ -1006,105 +1010,149 @@ const resolveReturnType = ({
1006
1010
  })
1007
1011
  }
1008
1012
  checkPredicateNameDeep(name, exp, exp.slice(1), returns)
1009
- // TODO: DRY
1010
- const index = env[name][STATS][ARGUMENTS]
1011
- ? env[name][STATS][ARGUMENTS].findIndex(
1012
- (x) => x[STATS][SIGNATURE] === returns[VALUE]
1013
- )
1014
- : -1
1015
-
1016
- if (index >= 0) {
1017
- setReturnToGeneric(env[name][STATS], index)
1018
- return true
1019
- } else if (!env[returns[VALUE]]) return false
1013
+ if (!env[returns[VALUE]]) return false
1020
1014
  else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
1021
1015
  if (returns[TYPE] === WORD) setReturnToAbstraction(env[name][STATS])
1022
- else {
1023
- // ALWAYS APPLY
1024
- // rest.at(-1)[0][TYPE] === APPLY
1025
- // Here is upon application to store the result in the variable
1026
- if (isUnknownType(env[name][STATS]))
1027
- stagger(stack, 'prepend', exp, () => {
1028
- if (isGenericReturn(env[returns[VALUE]][STATS])) {
1029
- // env[name][STATS][TYPE_PROP] =
1030
- const genericReturn =
1031
- rem.slice(1)[env[returns[VALUE]][STATS][RETURNS][2]]
1032
- const head = isLeaf(genericReturn)
1033
- ? genericReturn
1034
- : genericReturn[0]
1035
- switch (head[TYPE]) {
1036
- case ATOM:
1037
- setTypeToAtom(env[name][STATS])
1038
- break
1039
- case WORD:
1040
- if (env[head[VALUE]])
1041
- setStatsRef(env[name], env[head[VALUE]])
1042
- break
1043
- case APPLY:
1044
- switch (head[VALUE]) {
1045
- case KEYWORDS.ANONYMOUS_FUNCTION:
1046
- {
1047
- // TODO figure out a better way to do this
1048
- // This is initialization of identity or any other
1049
- // function that returns it's argument
1050
- // Redefine the variable but since it's an error doing that
1051
- // Delete it first
1052
- delete env[name]
1053
- check(
1054
- [
1055
- [APPLY, KEYWORDS.DEFINE_VARIABLE],
1056
- [WORD, name],
1057
- genericReturn
1058
- ],
1059
- env,
1060
- exp
1061
- )
1062
- // const n = genericReturn.length
1063
- // setTypeToAbstraction(env[name][STATS])
1064
- // env[name][STATS][ARG_COUNT] = n - 2
1065
- // env[name][STATS][ARGUMENTS] = fillUnknownArgs(
1066
- // n - 2
1067
- // )
1068
- // checkReturnType({
1069
- // exp: [genericReturn],
1070
- // stack,
1071
- // name,
1072
- // env,
1073
- // check
1074
- // })
1075
- }
1076
- break
1077
- case KEYWORDS.CREATE_ARRAY:
1078
- {
1079
- setTypeToCollection(env[name][STATS])
1080
- setPropToSubReturn(
1081
- env[name][STATS],
1082
- TYPE_PROP,
1083
- initArrayType({ rem: genericReturn, env })
1016
+ // ALWAYS APPLY
1017
+ // rest.at(-1)[0][TYPE] === APPLY
1018
+ // Here is upon application to store the result in the variable
1019
+ else if (isUnknownType(env[name][STATS]))
1020
+ stagger(stack, 'prepend', exp, () => {
1021
+ if (isGenericReturn(env[returns[VALUE]][STATS])) {
1022
+ // env[name][STATS][TYPE_PROP] =
1023
+ const [index, multiplier] =
1024
+ env[returns[VALUE]][STATS][RETURNS][2]
1025
+ const genericReturn = rem.slice(1)[index]
1026
+ const nestGeneric =
1027
+ env[returns[VALUE]][STATS][RETURNS][0] === COLLECTION
1028
+ ? isSubType(env[returns[VALUE]][STATS][RETURNS][1])
1029
+ ? env[returns[VALUE]][STATS][RETURNS][1].nestedLevels()
1030
+ : 0
1031
+ : 0
1032
+
1033
+ const head = isLeaf(genericReturn)
1034
+ ? genericReturn
1035
+ : genericReturn[0]
1036
+
1037
+ switch (head[TYPE]) {
1038
+ case ATOM:
1039
+ setTypeToAtom(env[name][STATS])
1040
+ break
1041
+ case WORD:
1042
+ if (env[head[VALUE]])
1043
+ env[name][STATS][prop] =
1044
+ env[head[VALUE]][STATS][TYPE_PROP]
1045
+ break
1046
+ case APPLY:
1047
+ switch (head[VALUE]) {
1048
+ case KEYWORDS.ANONYMOUS_FUNCTION:
1049
+ {
1050
+ // TODO figure out a better way to do this
1051
+ // This is initialization of identity or any other
1052
+ // function that returns it's argument
1053
+ // Redefine the variable but since it's an error doing that
1054
+ // Delete it first
1055
+ delete env[name]
1056
+ check(
1057
+ [
1058
+ [APPLY, KEYWORDS.DEFINE_VARIABLE],
1059
+ [WORD, name],
1060
+ genericReturn
1061
+ ],
1062
+ env,
1063
+ exp
1064
+ )
1065
+
1066
+ // const n = genericReturn.length
1067
+ // setTypeToAbstraction(env[name][STATS])
1068
+ // env[name][STATS][ARG_COUNT] = n - 2
1069
+ // env[name][STATS][ARGUMENTS] = fillUnknownArgs(
1070
+ // n - 2
1071
+ // )
1072
+ // checkReturnType({
1073
+ // exp: [genericReturn],
1074
+ // stack,
1075
+ // name,
1076
+ // env,
1077
+ // check
1078
+ // })
1079
+ }
1080
+ break
1081
+ case KEYWORDS.CREATE_ARRAY:
1082
+ {
1083
+ setTypeToCollection(env[name][STATS])
1084
+ setPropToSubReturn(
1085
+ env[name][STATS],
1086
+ TYPE_PROP,
1087
+ initArrayType({ rem: genericReturn, env })
1088
+ )
1089
+ }
1090
+ break
1091
+ default:
1092
+ break
1093
+ }
1094
+ break
1095
+ default:
1096
+ if (env[head[VALUE]])
1097
+ setTypeToReturn(
1098
+ env[name][STATS],
1099
+ env[head[VALUE]][STATS]
1100
+ )
1101
+ break
1102
+ }
1103
+ if (env[returns[VALUE]][STATS][RETURNS][0] === COLLECTION) {
1104
+ const T = isSubType(env[name][STATS][prop][1])
1105
+ ? env[name][STATS][prop][1].types
1106
+ : [env[name][STATS][prop][0]]
1107
+ if (multiplier === -1) {
1108
+ if (nestGeneric === 0) {
1109
+ if (T.at(-1) === NUMBER || T.at(-1) === BOOLEAN) {
1110
+ if (isSubType(env[name][STATS][prop][1])) {
1111
+ if (env[name][STATS][prop][1].types.length === 1)
1112
+ env[name][STATS][prop][0] = ATOM
1113
+ else {
1114
+ env[name][STATS][prop][1] = new SubType(
1115
+ env[name][STATS][prop][1].types.slice(1)
1084
1116
  )
1117
+ env[name][STATS][prop][0] = COLLECTION
1085
1118
  }
1086
- break
1119
+ } else env[name][STATS][prop][0] = ATOM
1120
+ }
1121
+ } else {
1122
+ if (T.length - nestGeneric - 1) {
1123
+ for (let i = 0; i < nestGeneric + 1; ++i)
1124
+ env[name][STATS][prop][1].types.shift()
1125
+ } else {
1126
+ if (T.at(-1) === NUMBER || T.at(-1) === BOOLEAN) {
1127
+ env[name][STATS][prop][0] = ATOM
1128
+ env[name][STATS][prop][0] = T.at(-1)
1129
+ } else {
1130
+ env[name][STATS][prop][0] = APPLY
1131
+ env[name][STATS][prop].length = 1
1132
+ }
1087
1133
  }
1088
- default:
1089
- if (env[head[VALUE]])
1090
- setTypeToReturn(
1091
- env[name][STATS],
1092
- env[head[VALUE]][STATS]
1093
- )
1094
- break
1134
+ }
1135
+ } else {
1136
+ const st = new SubType([])
1137
+ for (let i = 0; i < nestGeneric; ++i) st.add(COLLECTION)
1138
+ if (env[name][STATS][prop][0] === COLLECTION)
1139
+ st.add(COLLECTION)
1140
+ st.add(...T)
1141
+ env[name][STATS][prop][0] = COLLECTION
1142
+ env[name][STATS][prop][1] = st
1095
1143
  }
1096
- } else
1097
- setTypeToReturnRef(
1098
- env[name][STATS],
1099
- env[returns[VALUE]][STATS]
1100
- )
1101
- })
1102
- else {
1103
- // if (SPECIAL_FORMS_SET.has(returns[VALUE]))
1104
- // setReturn(env[name][STATS], env[returns[VALUE]][STATS])
1105
- // else
1106
- setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
1107
- }
1144
+ }
1145
+ } else
1146
+ setTypeToReturnRef(
1147
+ env[name][STATS],
1148
+ env[returns[VALUE]][STATS]
1149
+ )
1150
+ })
1151
+ else {
1152
+ // if (SPECIAL_FORMS_SET.has(returns[VALUE]))
1153
+ // setReturn(env[name][STATS], env[returns[VALUE]][STATS])
1154
+ // else
1155
+ setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
1108
1156
  }
1109
1157
  }
1110
1158
  }
@@ -1144,11 +1192,11 @@ export const typeCheck = (
1144
1192
  // TODO also handle casting
1145
1193
  const match = ({ rest, args, i, env, scope, exp }) => {
1146
1194
  const first = exp[0]
1147
- const actual =
1195
+ let actual =
1148
1196
  rest[i][0][VALUE] === KEYWORDS.CREATE_ARRAY
1149
1197
  ? initArrayType({ rem: rest[i], env })
1150
1198
  : env[rest[i][0][VALUE]][STATS]
1151
- const expected = args[i][STATS]
1199
+ let expected = args[i][STATS]
1152
1200
  retryArgs(args[i][STATS], exp, stack, () =>
1153
1201
  match({ rest, args, i, env, scope, exp })
1154
1202
  )
@@ -1212,6 +1260,14 @@ export const typeCheck = (
1212
1260
  const match1 = () => {
1213
1261
  const actual = local[lambdaName]
1214
1262
  const expected = args[i]
1263
+ // if (
1264
+ // isGenericReturn(args[i][STATS]) &&
1265
+ // !isUnknownReturn(actual[STATS]) &&
1266
+ // !isAnyReturn(actual[STATS])
1267
+ // ) {
1268
+ // args[i][STATS][RETURNS] = actual[STATS][RETURNS]
1269
+ // return
1270
+ // }
1215
1271
  if (
1216
1272
  !isUnknownReturn(expected[STATS]) &&
1217
1273
  !isUnknownReturn(actual[STATS]) &&
@@ -1249,48 +1305,65 @@ export const typeCheck = (
1249
1305
  )
1250
1306
  }
1251
1307
  match1()
1252
- for (let j = 0; j < args[i][STATS][ARGUMENTS].length; ++j) {
1253
- const actual = local[lambdaName][STATS][ARGUMENTS][j]
1254
- const expected = args[i][STATS][ARGUMENTS][j]
1255
- if (
1256
- !isUnknownType(actual[STATS]) &&
1257
- !isUnknownType(expected[STATS]) &&
1258
- (!equalTypes(actual[STATS], expected[STATS]) ||
1259
- !equalSubTypes(actual[STATS], expected[STATS]))
1260
- )
1261
- throw new TypeError(
1262
- `Incorrect type for (${KEYWORDS.ANONYMOUS_FUNCTION}) (${
1263
- args[i][STATS][SIGNATURE]
1264
- }) argument at position (${j}) named as (${
1265
- local[lambdaName][STATS][ARGUMENTS][j][STATS][
1266
- SIGNATURE
1267
- ]
1268
- }). Expected (${formatSubType(
1269
- getTypes(expected[STATS])
1270
- )}) but got (${formatSubType(
1271
- getTypes(actual[STATS])
1272
- )}) (${stringifyArgs(exp)}) (check #780)`
1273
- )
1274
- else if (!equalSubReturns(expected[STATS], actual[STATS]))
1275
- throw new TypeError(
1276
- `Incorrect return type for (${
1277
- expected[STATS][SIGNATURE]
1278
- }) the (${KEYWORDS.ANONYMOUS_FUNCTION}) argument of (${
1279
- first[VALUE]
1280
- }) at position (${i}). Expected (${formatSubType(
1281
- getReturns(expected[STATS])
1282
- )}) but got (${formatSubType(
1283
- getReturns(actual[STATS])
1284
- )}) (${stringifyArgs(exp)}) (check #784)`
1308
+ const match2 = () => {
1309
+ for (let j = 0; j < args[i][STATS][ARGUMENTS].length; ++j) {
1310
+ const actual = local[lambdaName][STATS][ARGUMENTS][j]
1311
+ const expected = args[i][STATS][ARGUMENTS][j]
1312
+ // if (
1313
+ // isGenericType(expected[STATS]) &&
1314
+ // !isUnknownType(actual[STATS]) &&
1315
+ // !isAnyType(actual[STATS])
1316
+ // ) {
1317
+ // expected[STATS][TYPE_PROP] = actual[STATS][TYPE_PROP]
1318
+ // return
1319
+ // }
1320
+
1321
+ if (
1322
+ !isUnknownType(actual[STATS]) &&
1323
+ !isUnknownType(expected[STATS]) &&
1324
+ (!equalTypes(actual[STATS], expected[STATS]) ||
1325
+ !equalSubTypes(actual[STATS], expected[STATS]))
1285
1326
  )
1286
- // else
1287
- // retry(
1288
- // actual[STATS],
1289
- // [[WORD, lambdaName], local],
1290
- // stack,
1291
- // match2
1292
- // )
1327
+ throw new TypeError(
1328
+ `Incorrect type for (${
1329
+ KEYWORDS.ANONYMOUS_FUNCTION
1330
+ }) (${
1331
+ args[i][STATS][SIGNATURE]
1332
+ }) argument at position (${j}) named as (${
1333
+ local[lambdaName][STATS][ARGUMENTS][j][STATS][
1334
+ SIGNATURE
1335
+ ]
1336
+ }). Expected (${formatSubType(
1337
+ getTypes(expected[STATS])
1338
+ )}) but got (${formatSubType(
1339
+ getTypes(actual[STATS])
1340
+ )}) (${stringifyArgs(exp)}) (check #780)`
1341
+ )
1342
+ else if (!equalSubReturns(expected[STATS], actual[STATS]))
1343
+ throw new TypeError(
1344
+ `Incorrect return type for (${
1345
+ expected[STATS][SIGNATURE]
1346
+ }) the (${
1347
+ KEYWORDS.ANONYMOUS_FUNCTION
1348
+ }) argument of (${
1349
+ first[VALUE]
1350
+ }) at position (${i}). Expected (${formatSubType(
1351
+ getReturns(expected[STATS])
1352
+ )}) but got (${formatSubType(
1353
+ getReturns(actual[STATS])
1354
+ )}) (${stringifyArgs(exp)}) (check #784)`
1355
+ )
1356
+ else {
1357
+ retry(
1358
+ actual[STATS],
1359
+ [[WORD, lambdaName], local],
1360
+ stack,
1361
+ match2
1362
+ )
1363
+ }
1364
+ }
1293
1365
  }
1366
+ match2()
1294
1367
  }
1295
1368
  } else {
1296
1369
  // TODO fix curry: lambdas enter here as undefined
@@ -1380,6 +1453,7 @@ export const typeCheck = (
1380
1453
  const checkReturns = () => {
1381
1454
  if (
1382
1455
  !isUnknownReturn(actual[STATS]) &&
1456
+ !isUnknownReturn(expected[STATS]) &&
1383
1457
  (!equalReturns(expected[STATS], actual[STATS]) ||
1384
1458
  !equalSubReturns(expected[STATS], actual[STATS]))
1385
1459
  )
@@ -1400,6 +1474,7 @@ export const typeCheck = (
1400
1474
  const argA = actual[STATS][ARGUMENTS][i]
1401
1475
  if (
1402
1476
  !isUnknownType(argA[STATS]) &&
1477
+ !isUnknownType(argE[STATS]) &&
1403
1478
  (!equalTypes(argE[STATS], argA[STATS]) ||
1404
1479
  !equalSubTypes(argE[STATS], argA[STATS]))
1405
1480
  )
@@ -1552,9 +1627,12 @@ export const typeCheck = (
1552
1627
  ? UNKNOWN
1553
1628
  : env[right[VALUE]][STATS][RETURNS][0]
1554
1629
 
1555
- if (type !== UNKNOWN && type !== ANY) {
1630
+ if (
1631
+ type !== UNKNOWN &&
1632
+ type !== ANY &&
1633
+ !isGenericReturn(env[right[VALUE]][STATS])
1634
+ )
1556
1635
  setTypeToReturn(env[name][STATS], env[right[VALUE]][STATS])
1557
- }
1558
1636
 
1559
1637
  const resolve = () => {
1560
1638
  const body = rightHand
@@ -1772,6 +1850,7 @@ export const typeCheck = (
1772
1850
  }
1773
1851
  // also type of arg
1774
1852
  const args = env[first[VALUE]][STATS][ARGUMENTS] ?? []
1853
+ // const generics = Array.from(args).fill(null)
1775
1854
  for (let i = 0; i < args.length; ++i) {
1776
1855
  // type check
1777
1856
  // TODO get rof pred type
@@ -1813,6 +1892,9 @@ export const typeCheck = (
1813
1892
  )
1814
1893
  }
1815
1894
  }
1895
+ // if (isGenericType(args[i][STATS])) {
1896
+ // generics[i] = env[name]
1897
+ // }
1816
1898
  const eqTypes = equalTypes(
1817
1899
  args[i][STATS],
1818
1900
  env[name][STATS]
@@ -1928,13 +2010,17 @@ export const typeCheck = (
1928
2010
  !equalSubTypes(args[i][STATS], env[name][STATS]))
1929
2011
  )
1930
2012
  setType(env[name][STATS], args[i][STATS])
1931
- else if (isUnknownType(env[name][STATS])) {
2013
+ else if (
2014
+ isUnknownType(env[name][STATS]) &&
2015
+ !isUnknownType(args[i][STATS])
2016
+ ) {
1932
2017
  // REFF ASSIGMENT
1933
2018
  // EXPLAIN: Not assigning ref fixes this overwriting
1934
2019
  // (let sum (lambda testxs (+ (get testxs 0) (get testxs 1))))
1935
2020
  // (let range (math:range 1 10))
1936
2021
  // (sum range)
1937
2022
  // But it reduces good inference too
2023
+
1938
2024
  if (getType(args[i][STATS]) !== APPLY)
1939
2025
  setTypeRef(env[name][STATS], args[i][STATS])
1940
2026
  else setStatsRef(env[rest[i][VALUE]], args[i])
@@ -1987,6 +2073,31 @@ export const typeCheck = (
1987
2073
  }
1988
2074
  }
1989
2075
  }
2076
+ // if (generics.some((x) => x !== null)) {
2077
+ // const copy = Object.create(env)
2078
+ // const genCopy = [...generics]
2079
+ // for (let i = 0; i < generics.length; ++i) {
2080
+ // if (!generics[i]) continue
2081
+ // genCopy[i] = structuredClone(
2082
+ // copy[first[VALUE]][STATS][ARGUMENTS][i]
2083
+ // )
2084
+ // copy[first[VALUE]][STATS][ARGUMENTS][i] = structuredClone(
2085
+ // generics[i]
2086
+ // )
2087
+ // copy[first[VALUE]][STATS][ARGUMENTS][i][STATS][
2088
+ // TYPE_PROP
2089
+ // ].length = 2
2090
+ // }
2091
+ // check(exp, copy, scope)
2092
+
2093
+ // for (let i = 0; i < generics.length; ++i) {
2094
+ // if (!generics[i]) continue
2095
+ // copy[first[VALUE]][STATS][ARGUMENTS][i] = genCopy[i]
2096
+ // copy[first[VALUE]][STATS][ARGUMENTS][i][STATS][
2097
+ // TYPE_PROP
2098
+ // ].length = 2
2099
+ // }
2100
+ // }
1990
2101
  }
1991
2102
  }
1992
2103
  stagger(stack, 'append', [first, env], judge)
package/src/debugger.js CHANGED
@@ -867,7 +867,14 @@ const evaluate = (exp, env = keywords) => {
867
867
  res = env[value]
868
868
  return res
869
869
  case APPLY:
870
- res = env[value](tail, env)
870
+ const apply = env[value]
871
+ if (apply == undefined)
872
+ throw new ReferenceError(
873
+ `Undefined (${
874
+ KEYWORDS.ANONYMOUS_FUNCTION
875
+ }) (${value}) (${stringifyArgs(exp)})`
876
+ )
877
+ res = apply(tail, env)
871
878
  if (
872
879
  isDebugging &&
873
880
  value !== KEYWORDS.BLOCK &&
@@ -949,6 +956,7 @@ export const debug = (ast, checkTypes = true, userDefinedTypes) => {
949
956
  if (option === 'Scope') {
950
957
  if (wildcard) {
951
958
  return [...types.entries()]
959
+ .filter((x) => x[0].split(' ').length === 3 && !x[0].includes('.'))
952
960
  .sort((a, b) => a[0].localeCompare(b[0]))
953
961
  .map(([k, v]) => `${k}\n${v()}`)
954
962
  .join('\n\n')
@@ -957,6 +965,7 @@ export const debug = (ast, checkTypes = true, userDefinedTypes) => {
957
965
  return t ? t() : ''
958
966
  } else if (option === 'Search') {
959
967
  return [...types.entries()]
968
+ .filter((x) => x[0].split(' ').length === 3 && !x[0].includes('.'))
960
969
  .filter((x) => x[0].includes(name))
961
970
  .sort((a, b) => a[0].localeCompare(b[0]))
962
971
  .map(([k, v]) => `${k}\n${v()}`)
@@ -964,13 +973,24 @@ export const debug = (ast, checkTypes = true, userDefinedTypes) => {
964
973
  } else if (option === 'Special') {
965
974
  return formatType(name, SPECIAL_FORM_TYPES)
966
975
  } else if (option === 'Type') {
976
+ types = typeCheck(std[0], withCtxTypes(definedTypes(stdT)))[1]
967
977
  const [from, to] = name.split(KEYWORDS.BLOCK).map((x) => x.trim())
968
978
  return [...types.entries()]
979
+ .filter((x) => x[0].split(' ').length === 3 && !x[0].includes('.'))
969
980
  .filter(([k, v]) => {
970
981
  const T = v()
971
- if (T && T.includes(KEYWORDS.BLOCK)) {
972
- const [left, right] = T.split(KEYWORDS.BLOCK).map((x) => x.trim())
973
- return left.includes(from) && right.includes(to)
982
+ if (T) {
983
+ const last = LISP.parse(T).at(-1).at(-1)
984
+ if (last[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION) {
985
+ const [left, right] = last
986
+ .slice(1)
987
+ .flat(Infinity)
988
+ .filter((x) => x.length)
989
+ .join(' ')
990
+ .split(KEYWORDS.BLOCK)
991
+ .map((x) => x.trim())
992
+ return left.includes(from) && right.includes(to)
993
+ }
974
994
  }
975
995
  })
976
996
  .sort((a, b) => a[0].length - b[0].length)
@@ -979,8 +999,14 @@ export const debug = (ast, checkTypes = true, userDefinedTypes) => {
979
999
  } else if (option === 'Library') {
980
1000
  types = typeCheck(std[0], withCtxTypes(definedTypes(stdT)))[1]
981
1001
  const matches = wildcard
982
- ? [...types.entries()]
983
- : [...types.entries()].filter(([k, v]) => v().includes(name))
1002
+ ? [...types.entries()].filter(
1003
+ (x) => x[0].split(' ').length === 3 && !x[0].includes('.')
1004
+ )
1005
+ : [...types.entries()]
1006
+ .filter(
1007
+ (x) => x[0].split(' ').length === 3 && !x[0].includes('.')
1008
+ )
1009
+ .filter(([k, v]) => v().includes(name))
984
1010
  return matches
985
1011
  .sort((a, b) => a[0].length - b[0].length)
986
1012
  .map(([k, v]) => `${k}\n${v()}`)