fez-lisp 1.6.89 → 1.6.91

package/package.json

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

package/src/check.js

@@ -614,27 +614,95 @@ const IfApplyBranch = ({
       return setPropToReturn(ref[STATS], prop, branch[STATS])
   }
 }
+const inferIf = (branch, re, env, name) => {
+  switch (branch[TYPE]) {
+    case ATOM:
+      return [[ATOM, NUMBER_SUBTYPE()]]
+    case WORD:
+      if (branch[VALUE] === NIL) return [[UNKNOWN]]
+      if (env[branch[VALUE]]) return [env[branch[VALUE]][STATS][TYPE_PROP]]
+      break
+    case APPLY:
+      if (branch[VALUE] !== name && env[branch[VALUE]])
+        if (branch[VALUE] === KEYWORDS.CREATE_ARRAY) {
+          return [initArrayType({ rem: re, env })[RETURNS]]
+        } else if (branch[VALUE] === KEYWORDS.IF) {
+          const conc = isLeaf(re[2]) ? re[2] : re[2][0]
+          const alt = isLeaf(re[3]) ? re[3] : re[3][0]
+          return inferIf(conc, re[2], env, name).concat(
+            inferIf(alt, re[3], env, name)
+          )
+        } else return [env[branch[VALUE]][STATS][RETURNS]]
+      break
+  }
+  return []
+}
+const validateIfMatchingBranches = (
+  concequent,
+  alternative,
+  env,
+  exp,
+  re,
+  name
+) => {
+  const A = inferIf(concequent, re[0], env, name).filter(
+    (x) => x[0] !== UNKNOWN && x[0] !== ANY
+  )
+  const B = inferIf(alternative, re[1], env, name).filter(
+    (x) => x[0] !== UNKNOWN && x[0] !== ANY
+  )
+
+  if (!A.length || !B.length) return
+
+  const isSame = (A, B) => {
+    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)`
+      )
+    }
+  }
+  A.forEach((x) => isSame(A[0], x))
+  B.forEach((x) => isSame(B[0], x))
+
+  const FA = A[0]
+  const FB = B[0]
+  if (
+    FA[0] !== FB[0] ||
+    (isSubType(FA[1]) && isSubType(FB[1]) && !FA[1].isMatching(FB[1]))
+  ) {
+    throw new TypeError(
+      `(if) needs to have matching concequent and alternative branches but got (${formatSubType(
+        FA
+      )}) and (${formatSubType(FB)}) (${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 +714,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 +734,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 +1024,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]
@@ -2114,7 +2185,7 @@ export const typeCheck = (
                     (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][
@@ -2229,7 +2300,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)
@@ -2240,7 +2312,7 @@ export const typeCheck = (
                   }
                   copy[newName][STATS][SIGNATURE] = newName
 
-                  rec(copy[newName])
+                  genericRecursiveDecent(copy[newName])
 
                   const cexp = structuredClone(exp)
                   copy[newName][STATS].source = structuredClone(
@@ -2260,6 +2332,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)