fez-lisp 1.6.87 → 1.6.90

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.6.87",
+  "version": "1.6.90",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/check.js

@@ -365,13 +365,12 @@ const getGenericProp = (ref, rem, prop) => {
 const getGenericReturn = (ref, rem) => getGenericProp(ref, rem, RETURNS)
 const getGenericType = (ref, rem) => getGenericProp(ref, rem, TYPE_PROP)
 const resolveGenericNest = (ref, prop, nestGeneric, multiplier) => {
-  const T = isSubType(ref[STATS][prop][1])
-    ? ref[STATS][prop][1].types
-    : [ref[STATS][prop][0]]
+  const hasSubType = isSubType(ref[STATS][prop][1])
+  const T = hasSubType ? ref[STATS][prop][1].types : [ref[STATS][prop][0]]
   if (multiplier === -1) {
     if (nestGeneric === 0) {
       if (T.at(-1) === NUMBER || T.at(-1) === BOOLEAN) {
-        if (isSubType(ref[STATS][prop][1])) {
+        if (hasSubType) {
           if (ref[STATS][prop][1].types.length === 1) ref[STATS][prop][0] = ATOM
           else {
             ref[STATS][prop][1] = new SubType(
@@ -384,8 +383,9 @@ const resolveGenericNest = (ref, prop, nestGeneric, multiplier) => {
       }
     } else {
       if (T.length - nestGeneric - 1) {
-        for (let i = 0; i < nestGeneric + 1; ++i)
-          ref[STATS][prop][1].types.shift()
+        if (hasSubType)
+          for (let i = 0; i < nestGeneric + 1; ++i)
+            ref[STATS][prop][1].types.shift()
         ref[STATS][prop].length = 2
       } else {
         if (T.at(-1) === NUMBER || T.at(-1) === BOOLEAN) {
@@ -614,27 +614,108 @@ const IfApplyBranch = ({
       return setPropToReturn(ref[STATS], prop, branch[STATS])
   }
 }
+
+const validateIfMatchingBranches = (
+  concequent,
+  alternative,
+  env,
+  exp,
+  re,
+  name
+) => {
+  let A = null
+  let B = null
+  switch (concequent[TYPE]) {
+    case ATOM:
+      A = [ATOM, NUMBER_SUBTYPE()]
+      break
+    case WORD:
+      if (concequent[VALUE] === NIL) return
+      if (env[concequent[VALUE]]) A = env[concequent[VALUE]][STATS][TYPE_PROP]
+      break
+    case APPLY:
+      if (concequent[VALUE] !== name && env[concequent[VALUE]])
+        if (concequent[VALUE] === KEYWORDS.CREATE_ARRAY) {
+          A = initArrayType({ rem: re[0], env })[RETURNS]
+        } else if (concequent[VALUE] === KEYWORDS.IF && re[0][2]) {
+          const conc = isLeaf(re[0][2]) ? re[0][2] : re[0][2][0]
+          validateIfMatchingBranches(
+            conc,
+            alternative,
+            env,
+            exp,
+            isLeaf(re[0]) ? re[0].slice(2) : re[0].slice(2),
+            name
+          )
+        } else A = env[concequent[VALUE]][STATS][RETURNS]
+      break
+  }
+  switch (alternative[TYPE]) {
+    case ATOM:
+      B = [ATOM, NUMBER_SUBTYPE()]
+      break
+    case WORD:
+      if (alternative[VALUE] === NIL) return
+      if (env[alternative[VALUE]]) B = env[alternative[VALUE]][STATS][TYPE_PROP]
+      break
+    case APPLY:
+      if (alternative[VALUE] !== name && env[alternative[VALUE]])
+        if (alternative[VALUE] === KEYWORDS.CREATE_ARRAY) {
+          B = initArrayType({ rem: re[1], env })[RETURNS]
+        } else if (alternative[VALUE] === KEYWORDS.IF && re[1][2]) {
+          const alt = isLeaf(re[1][2]) ? re[1][2] : re[1][2][0]
+          validateIfMatchingBranches(
+            concequent,
+            alt,
+            env,
+            exp,
+            isLeaf(re[1]) ? re[1].slice(2) : re[1].slice(2),
+            name
+          )
+        } else B = env[alternative[VALUE]][STATS][RETURNS]
+      break
+  }
+  if (
+    A === null ||
+    B === null ||
+    A[0] === UNKNOWN ||
+    B[0] === UNKNOWN ||
+    A[0] === ANY ||
+    B[0] === ANY
+  )
+    return
+  if (
+    A[0] !== B[0] ||
+    (isSubType(A[1]) && isSubType(B[1]) && !A[1].isMatching(B[1]))
+  ) {
+    throw new TypeError(
+      `(if) needs to have matching concequent and alternative branches but got (${formatSubType(
+        A
+      )}) and (${formatSubType(B)}) (${stringifyArgs(exp)}) (check #1005)`
+    )
+  }
+}
 const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
-  if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM)
-    return setPropToAtom(ref[STATS], prop)
+  const conc = isLeaf(re[0]) ? re[0] : re[0][0]
+  const alt = isLeaf(re[1]) ? re[1] : re[1][0]
+  const concequent = env[conc[VALUE]]
+  const alternative = env[alt[VALUE]]
+  if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM) {
+    setPropToAtom(ref[STATS], prop)
+  }
   // TODO check that both branches are predicates if one is
   else {
-    const conc = isLeaf(re[0]) ? re[0] : re[0][0]
-    const alt = isLeaf(re[1]) ? re[1] : re[1][0]
-    const concequent = env[conc[VALUE]]
-    const alternative = env[alt[VALUE]]
-
     // TODO make this more simple - it's so many different things just because types are functions or not
     // WHY not consider making return types for everything
     if (concequent)
       if (conc[TYPE] === WORD) {
-        return setPropToTypeRef(ref[STATS], prop, concequent[STATS])
+        setPropToTypeRef(ref[STATS], prop, concequent[STATS])
       } else if (
         conc[TYPE] === APPLY &&
         getType(concequent[STATS]) === APPLY &&
         // Making sure the recursive function don't look for their own return type
         concequent[STATS][SIGNATURE] !== ref[STATS][SIGNATURE]
-      ) {
+      )
         IfApplyBranch({
           leaf: conc,
           branch: concequent,
@@ -646,16 +727,15 @@ const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
           exp,
           check
         })
-      }
-    if (alternative) {
+    if (alternative)
       if (alt[TYPE] === WORD) {
-        return setPropToTypeRef(ref[STATS], prop, alternative[STATS])
+        setPropToTypeRef(ref[STATS], prop, alternative[STATS])
       } else if (
         alt[TYPE] === APPLY &&
         getType(alternative[STATS]) === APPLY &&
         // Making sure the recursive function don't look for their own return type
         alternative[STATS][SIGNATURE] !== ref[STATS][SIGNATURE]
-      ) {
+      )
         IfApplyBranch({
           leaf: alt,
           branch: alternative,
@@ -667,9 +747,8 @@ const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
           exp,
           check
         })
-      }
-    }
   }
+  validateIfMatchingBranches(conc, alt, env, exp, re, ref[STATS][SIGNATURE])
 }
 const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
   const ret = rem[0]
@@ -958,8 +1037,13 @@ const initArrayTypeRec = ({ rem, env }) =>
           x[TYPE] === ATOM ? NUMBER_SUBTYPE() : new SubType([UNKNOWN])
         ]
     else if (env[x[0][VALUE]])
-      if (x.length > 1 && env[x[0][VALUE]][STATS][RETURNS][0] === COLLECTION)
+      if (x.length > 1 && x[0][VALUE] === KEYWORDS.CREATE_ARRAY)
         return initArrayTypeRec({ rem: x, env })
+      else if (
+        x.length > 1 &&
+        env[x[0][VALUE]][STATS][RETURNS][0] === COLLECTION
+      )
+        return [getReturns(env[x[0][VALUE]][STATS])]
       else if (GET_ARRAY_INFERENCE_SET.has(x[0][VALUE])) {
         const res = resolveGetterRec(x, env)
         if (!res) return [UNKNOWN]
@@ -1884,6 +1968,7 @@ export const typeCheck = (
                     }
                   }
                 }
+
                 // also type of arg
                 const args = env[first[VALUE]][STATS][ARGUMENTS] ?? []
                 for (let i = 0; i < args.length; ++i) {
@@ -2078,11 +2163,8 @@ export const typeCheck = (
                         isUnknownReturn(env[name][STATS]) &&
                         !env[name][STATS][IS_ARGUMENT]
                       )
-                        return retry(
-                          env[name][STATS],
-                          [first, env],
-                          stack,
-                          () => check(exp, env, scope)
+                        retry(env[name][STATS], [first, env], stack, () =>
+                          check(exp, env, scope)
                         )
                       else if (
                         env[name] &&
@@ -2109,13 +2191,14 @@ export const typeCheck = (
                 // GENERICS CODE START
                 if (
                   first[VALUE][0] !== PLACEHOLDER &&
-                  env[first[VALUE]][STATS].source &&
+                  env[first[VALUE]][STATS][ARGUMENTS] &&
                   env[first[VALUE]][STATS][ARGUMENTS].length &&
+                  env[first[VALUE]][STATS].source &&
                   env[first[VALUE]][STATS][ARGUMENTS].some(
                     (x) => isGenericType(x[STATS]) || isGenericReturn(x[STATS])
                   )
                 ) {
-                  const rec = (ref) => {
+                  const genericRecursiveDecent = (ref) => {
                     if (isGenericReturn(ref[STATS])) {
                       const [index, multiplier] = ref[STATS][RETURNS][2]
                       const desiredTypeIndex = env[first[VALUE]][STATS][
@@ -2180,7 +2263,6 @@ export const typeCheck = (
                           const desiredType = isLeaf(rest[desiredTypeIndex])
                             ? rest[desiredTypeIndex]
                             : rest[desiredTypeIndex][0]
-
                           switch (desiredType[TYPE]) {
                             case ATOM:
                               expected[STATS][TYPE_PROP] = [
@@ -2231,7 +2313,8 @@ export const typeCheck = (
                           expected[STATS][TYPE_PROP].length = 2
                         }
                       }
-                      if (expected[STATS][ARGUMENTS].length) rec(expected)
+                      if (expected[STATS][ARGUMENTS].length)
+                        genericRecursiveDecent(expected)
                     }
                   }
                   const copy = Object.create(env)
@@ -2242,7 +2325,7 @@ export const typeCheck = (
                   }
                   copy[newName][STATS][SIGNATURE] = newName
 
-                  rec(copy[newName])
+                  genericRecursiveDecent(copy[newName])
 
                   const cexp = structuredClone(exp)
                   copy[newName][STATS].source = structuredClone(
@@ -2250,7 +2333,6 @@ export const typeCheck = (
                   )
                   cexp[0][VALUE] = newName
                   copy[newName][STATS].source[1][VALUE] = newName
-
                   doOnce(copy[newName][STATS], cexp, stack, () => {
                     check(
                       wrapInArray([copy[newName][STATS].source, cexp]),
@@ -2263,6 +2345,7 @@ export const typeCheck = (
                 }
               }
             }
+
             stagger(stack, 'append', [first, env], judge)
             stagger(stack, 'prepend', [first, env], judge)
             for (let i = 0; i < rest.length; ++i) {

package/src/compiler.js

@@ -276,18 +276,17 @@ const comp = (tree, Drill) => {
         )}}return -1})();`
       }
 
-      case STATIC_TYPES.ABSTRACTION:
-      case STATIC_TYPES.COLLECTION:
-      case STATIC_TYPES.UNKNOWN:
-      case STATIC_TYPES.ATOM:
-      case STATIC_TYPES.BOOLEAN:
-      case STATIC_TYPES.ANY:
-      case STATIC_TYPES.NUMBER:
-      case STATIC_TYPES.NUMBERS:
-      case STATIC_TYPES.ABSTRACTIONS:
-      case STATIC_TYPES.BOOLEANS:
-      case STATIC_TYPES.COLLECTIONS:
-      case STATIC_TYPES.AS_NUMBER:
+      // case STATIC_TYPES.ABSTRACTION:
+      // case STATIC_TYPES.COLLECTION:
+      // case STATIC_TYPES.UNKNOWN:
+      // case STATIC_TYPES.ATOM:
+      // case STATIC_TYPES.BOOLEAN:
+      // case STATIC_TYPES.ANY:
+      // case STATIC_TYPES.NUMBER:
+      // case STATIC_TYPES.NUMBERS:
+      // case STATIC_TYPES.ABSTRACTIONS:
+      // case STATIC_TYPES.BOOLEANS:
+      // case STATIC_TYPES.COLLECTIONS:
       case DEBUG.LOG:
       case DEBUG.STRING:
       case DEBUG.UNQUOTED_STRING:

package/src/enhance.js

@@ -36,11 +36,6 @@ const opt = (ast) => {
         case APPLY:
           {
             switch (first[VALUE]) {
-              case STATIC_TYPES.AS_NUMBER:
-                exp.length = 0
-                for (let i = 0; i < rest.length; ++i) exp.push(...rest[i])
-                evaluate(exp)
-                break
               case KEYWORDS.DEFINE_VARIABLE:
                 {
                   const last = exp.at(-1)
@@ -257,7 +252,6 @@ export const removeCast = (ast) => {
               case STATIC_TYPES.ABSTRACTIONS:
               case STATIC_TYPES.BOOLEANS:
               case STATIC_TYPES.COLLECTIONS:
-              case STATIC_TYPES.AS_NUMBER:
                 exp.length = 0
                 for (let i = 0; i < rest.length; ++i) exp.push(...rest[i])
                 evaluate(exp)

package/src/keywords.js

@@ -20,7 +20,6 @@ export const STATIC_TYPES = {
   BOOLEANS: 'Booleans',
   ABSTRACTIONS: 'Abstractions',
   COLLECTIONS: 'Collections',
-  AS_NUMBER: 'numberp',
   ANY: 'Any',
   DEFINE_TYPE: 'the'
 }

package/src/macros.js

@@ -16,7 +16,7 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { hasBlock, stringifyArgs } from './utils.js'
+import { hasBlock, logExp, stringifyArgs } from './utils.js'
 import { NIL } from './types.js'
 export const SUGGAR = {
   // Syntactic suggars
@@ -382,6 +382,15 @@ export const deSuggarAst = (ast, scope) => {
                   exp[0][TYPE] = ATOM
                   exp[0][VALUE] = FALSE
                 } else if (rest.length > 2) {
+                  // TODO: maybe one day implement
+                  // Constant folding
+                  // it works sort of like this
+                  // while (
+                  //   rest.at(-2) &&
+                  //   rest.at(-1)[TYPE] === ATOM &&
+                  //   rest.at(-2)[TYPE] === ATOM
+                  // )
+                  //   rest[rest.length - 2][VALUE] += rest.pop()[VALUE]
                   exp.length = 0
                   let temp = exp
                   for (let i = 0; i < rest.length; i += 1) {
@@ -522,7 +531,11 @@ export const deSuggarAst = (ast, scope) => {
                         KEYWORDS.IF
                       } ${stringifyArgs(rest)})`
                     )
-                  if (rest.length === 2) exp.push([WORD, NIL])
+                  if (rest.length === 2) {
+                    // for this to work also make nil to be a false boolean
+                    // exp[2] = [[APPLY, 'logic:true'], exp[2]]
+                    exp.push([WORD, NIL])
+                  }
                 }
                 deSuggarAst(exp[1], scope)
                 break

package/src/parser.js

@@ -150,7 +150,6 @@ export const AST = {
             case STATIC_TYPES.ABSTRACTIONS:
             case STATIC_TYPES.BOOLEANS:
             case STATIC_TYPES.COLLECTIONS:
-            case STATIC_TYPES.AS_NUMBER:
               out += dfs(tail[0])
               break
             default:
@@ -193,7 +192,6 @@ export const AST = {
             case STATIC_TYPES.ABSTRACTIONS:
             case STATIC_TYPES.BOOLEANS:
             case STATIC_TYPES.COLLECTIONS:
-            case STATIC_TYPES.AS_NUMBER:
               out += dfs(tail[0])
               break
             default:
@@ -241,7 +239,6 @@ pub fn ${mod}() -> Expression { ${str} }`
             case STATIC_TYPES.ABSTRACTIONS:
             case STATIC_TYPES.BOOLEANS:
             case STATIC_TYPES.COLLECTIONS:
-            case STATIC_TYPES.AS_NUMBER:
               out += dfs(tail[0])
               break
             default:

package/src/types.js

@@ -234,27 +234,6 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM]
     }
   },
-  [STATIC_TYPES.AS_NUMBER]: {
-    [STATS]: {
-      [TYPE_PROP]: [APPLY],
-      [SIGNATURE]: STATIC_TYPES.AS_NUMBER,
-      retried: Infinity,
-      [ARG_COUNT]: 1,
-      [ARGUMENTS]: [
-        {
-          [STATS]: {
-            retried: Infinity,
-            [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, SPECIAL_BOOLEAN],
-            [RETURNS]: [ATOM, SPECIAL_BOOLEAN],
-            [ARGUMENTS]: [],
-            [ARG_COUNT]: 0
-          }
-        }
-      ],
-      [RETURNS]: [ATOM, SPECIAL_NUMBER]
-    }
-  },
   [STATIC_TYPES.BOOLEAN]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],

package/src/utils.js

@@ -273,7 +273,7 @@ const toIgnore = (ast) => {
         break
     }
   }
-  dfs(ast[0])
+  dfs(ast)
   return out
   // ast.filter(([x]) => isDefinition(x)).map(([_, x]) => x[VALUE])
 }
@@ -282,12 +282,12 @@ export const treeShake = (ast, libs) => {
   const visited = new Set()
   const ignored = new Set(toIgnore(ast))
   deepShake(ast, deps, visited, ignored)
-  return extractDeps(visited, deps)
+  return [extractDeps(visited, deps), visited]
 }
 export const shakedList = (ast, libs) => {
   const deps = toDeps(libs)
   const visited = new Set()
-  const ignored = new Set(toIgnore(ast))
+  const ignored = new Set(toIgnore(ast[0]))
   deepShake(ast, deps, visited, ignored)
   const out = []
   for (const [key] of deps) if (visited.has(key)) out.push(key)
@@ -311,7 +311,10 @@ export const wrapInApplyLambda = (ast) => [
 ]
 export const interpret = (ast, keywords) =>
   ast.reduce((_, x) => evaluate(x, keywords), 0)
-export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)
+export const shake = (parsed, std) => {
+  const [shaked] = treeShake(parsed, std)
+  return shaked.concat(parsed)
+}
 export const tree = (source, std) =>
   std
     ? shake(LISP.parse(deSuggarSource(removeNoCode(source))), std)