fez-lisp 1.5.159 → 1.5.161

package/package.json

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

package/src/check.js

@@ -309,7 +309,22 @@ export const equalTypes = (a, b) => {
   if (!isSameType) return false
   return true
 }
-
+const isRedifinedInLambda = (env, name, exp) => {
+  if (exp.slice(1, -1).some((x) => x[VALUE] === name)) return true
+  else if (
+    exp
+      .at(-1)
+      .some(
+        (x) =>
+          !isLeaf(x) &&
+          x[0][TYPE] === APPLY &&
+          x[0][VALUE] === KEYWORDS.DEFINE_VARIABLE &&
+          x[1][VALUE] === name
+      )
+  )
+    return true
+  else return false
+}
 export const equalReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const equalsTypeWithReturn = (a, b) =>
@@ -523,7 +538,6 @@ const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
     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 consiter making return types for everything
     if (concequent)
@@ -608,7 +622,11 @@ const resolveSetter = (first, rest, env, stack) => {
       : new Set([UNKNOWN])
     switch (right[TYPE]) {
       case ATOM:
-        if (!currentSubType.has(UNKNOWN) && !currentSubType.has(NUMBER))
+        if (
+          !currentSubType.has(ANY) &&
+          !currentSubType.has(UNKNOWN) &&
+          !currentSubType.has(NUMBER)
+        )
           throw new TypeError(
             `Incorrect array type at (${
               first[VALUE]
@@ -1175,10 +1193,18 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                     name,
                     check
                   })
+                  // TODO: remove this as maybe it is not needed
                   check(rightHand, env, exp)
                 })
                 check(rightHand, env, exp)
-              } else check(rightHand, env, exp)
+              }
+
+              check(rightHand, env, exp)
+
+              // if (isUnknownReturn(env[name][STATS]))
+              //   retry(env[name][STATS], exp, stack, () =>
+              //     check(rightHand, env, exp)
+              //   )
             } else {
               checkPredicateName(exp, rest)
               const isLeafNode = isLeaf(rightHand)
@@ -1225,19 +1251,24 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                   : env[right[VALUE]][STATS][RETURNS][0]
                 if (type !== UNKNOWN)
                   setTypeToReturn(env[name][STATS], env[right[VALUE]][STATS])
-                const body = rightHand
-                const rem = hasBlock(body) ? body.at(-1) : body
-                const returns = isLeaf(rem) ? rem : rem[0]
-                resolveReturnType({
-                  stack,
-                  returns,
-                  rem,
-                  prop: TYPE_PROP,
-                  exp,
-                  env,
-                  name,
-                  check
-                })
+                const resolve = () => {
+                  const body = rightHand
+                  const rem = hasBlock(body) ? body.at(-1) : body
+                  const returns = isLeaf(rem) ? rem : rem[0]
+                  resolveReturnType({
+                    stack,
+                    returns,
+                    rem,
+                    prop: TYPE_PROP,
+                    exp,
+                    env,
+                    name,
+                    check
+                  })
+                }
+                resolve()
+                if (isUnknownType(env[name][STATS]))
+                  once(env[name][STATS], exp, stack, () => resolve())
               }
               check(rightHand, env, scope)
             }
@@ -1312,9 +1343,13 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                       })
                       break
                     default:
-                      if (copy[ret[VALUE]])
-                        setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
-                      else
+                      if (copy[ret[VALUE]]) {
+                        if (isUnknownReturn(copy[ret[VALUE]][STATS])) {
+                          once(ref[STATS], [returns, copy], stack, () => {
+                            setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
+                          })
+                        } else setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
+                      } else
                         stagger(stack, 'append', [ret, copy], () => {
                           if (copy[ret[VALUE]])
                             setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])

package/src/types.js

@@ -76,7 +76,8 @@ export const toTypeCodes = (type) => {
     case 'Unknown':
       return [UNKNOWN]
     case 'Unknowns':
-      return [COLLECTION]
+    case 'Collection':
+      return [COLLECTION, new Set([ANY])]
     case 'Numbers':
       return [COLLECTION, NUMBER_SUBTYPE()]
     case 'Booleans':

package/src/utils.js

@@ -175,10 +175,13 @@ const isDefinition = (x) =>
   x[TYPE] === APPLY && x[VALUE] === KEYWORDS.DEFINE_VARIABLE
 // [[, [, libs]]] is because std is wrapped in (apply (lambda (do ...)))
 const toDeps = ([[, [, libs]]]) =>
-  libs.reduce(
-    (a, x, i) => a.set(x.at(1)[VALUE], { value: x, index: i }),
-    new Map()
-  )
+  // slice 1 so we get rid of do
+  libs
+    .slice(1)
+    .reduce(
+      (a, x, i) => a.set(x.at(1)[VALUE], { value: x, index: i }),
+      new Map()
+    )
 const deepShake = (tree, deps, visited = new Set(), ignored = new Set()) => {
   const type = tree[TYPE]
   const value = tree[VALUE]