fez-lisp 1.5.101 → 1.5.103

package/package.json

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

package/src/check.js

@@ -37,6 +37,7 @@ import {
   validateLambda
 } from './types.js'
 import {
+  Brr,
   getSuffix,
   hasApplyLambdaBlock,
   hasBlock,
@@ -146,12 +147,12 @@ export const compareReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const compareTypeWithReturn = (a, b) =>
   isAnyType(a) || isAnyReturn(b) || a[TYPE_PROP][0] === b[RETURNS][0]
-const checkPredicateName = (exp, rest, errors) => {
+const checkPredicateName = (exp, rest) => {
   if (getSuffix(rest[0][VALUE]) === PREDICATE_SUFFIX) {
     const last = rest.at(-1)
     if (isLeaf(last)) {
       if (last[TYPE] === ATOM && last[VALUE] !== TRUE && last[VALUE] !== FALSE)
-        errors.add(
+        throw new TypeError(
           `Assigning predicate (ending in ?) variable (${
             rest[0][VALUE]
           }) to an (${
@@ -163,7 +164,7 @@ const checkPredicateName = (exp, rest, errors) => {
         getSuffix(last[VALUE]) !== PREDICATE_SUFFIX &&
         !PREDICATES_OUTPUT_SET.has(last[VALUE])
       )
-        errors.add(
+        throw new TypeError(
           `Assigning predicate (ending in ?) variable (${
             rest[0][VALUE]
           }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
@@ -181,7 +182,7 @@ const checkPredicateName = (exp, rest, errors) => {
             getSuffix(application[VALUE]) !== PREDICATE_SUFFIX &&
             !PREDICATES_OUTPUT_SET.has(application[VALUE])
           )
-            errors.add(
+            throw new TypeError(
               `Assigning predicate (ending in ?) variable (${
                 application[VALUE]
               }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
@@ -193,21 +194,17 @@ const checkPredicateName = (exp, rest, errors) => {
     }
   }
 }
-const checkPredicateNameDeep = (name, exp, rest, returns, errors) => {
+const checkPredicateNameDeep = (name, exp, rest, returns) => {
   if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
     const fn = rest.at(-1).at(-1).at(-1)
-    checkPredicateName(
-      exp,
-      [
-        [WORD, name],
-        isLeaf(fn)
-          ? fn // when apply is a word (let x? (lambda (apply [] array:empty!)))
-          : drillReturnType(fn, (r) => r[VALUE] === KEYWORDS.CALL_FUNCTION) // when apply is an annonymous lambda // (let fn? (lambda x (apply x (lambda x (array:empty! [])))))
-      ],
-      errors
-    )
+    checkPredicateName(exp, [
+      [WORD, name],
+      isLeaf(fn)
+        ? fn // when apply is a word (let x? (lambda (apply [] array:empty!)))
+        : drillReturnType(fn, (r) => r[VALUE] === KEYWORDS.CALL_FUNCTION) // when apply is an annonymous lambda // (let fn? (lambda x (apply x (lambda x (array:empty! [])))))
+    ])
   } else {
-    checkPredicateName(exp, [[WORD, name], returns], errors)
+    checkPredicateName(exp, [[WORD, name], returns])
   }
 }
 const fillUknownArgs = (n) =>
@@ -238,20 +235,19 @@ const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
   return `${chain.length === 1 ? '; ' : ''}${chain.join(' ')} ${name}`
 }
-const retry = (stats, stack, errors, cb) => {
+const retry = (stats, stack, cb) => {
   if (
-    errors.size === 0 &&
     (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
     stats.retried < MAX_RETRY_DEFINITION
   ) {
     stats.retried += 1
-    stack.unshift(() => cb())
+    stack.prepend(() => cb())
   }
 }
-const retryArgs = (stats, stack, errors, cb) => {
-  if (errors.size === 0 && stats.counter < MAX_ARGUMENT_RETRY) {
+const retryArgs = (stats, stack, cb) => {
+  if (stats.counter < MAX_ARGUMENT_RETRY) {
     stats.counter++
-    stack.unshift(cb)
+    stack.prepend(cb)
   }
 }
 const ifExpression = ({ re, env, ref }) => {
@@ -291,18 +287,10 @@ const resolveApplyAssigment = (re, name, env) => {
     }
   }
 }
-const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
+const resolveIfAssigment = ({ rem, name, env, exp, prop }) => {
   const re = rem.slice(2)
-  checkPredicateName(
-    exp,
-    [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]],
-    errors
-  )
-  checkPredicateName(
-    exp,
-    [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]],
-    errors
-  )
+  checkPredicateName(exp, [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]])
+  checkPredicateName(exp, [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]])
   if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM)
     // ATOM ASSIGMENT
     setPropToAtom(env[name][STATS], prop)
@@ -328,21 +316,13 @@ const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
     // ASSIGMENT
     setPropRef(env[name][STATS], prop, env[re[1][VALUE]][STATS])
 }
-const resolveCondition = ({ rem, name, env, exp, errors }) => {
+const resolveCondition = ({ rem, name, env, exp }) => {
   const ret = rem[0]
   const re = rem.slice(2)
   resolveApplyAssigment(re, name, env)
   const ref = env[name]
-  checkPredicateName(
-    exp,
-    [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]],
-    errors
-  )
-  checkPredicateName(
-    exp,
-    [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]],
-    errors
-  )
+  checkPredicateName(exp, [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]])
+  checkPredicateName(exp, [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]])
   switch (ret[VALUE]) {
     case KEYWORDS.IF:
       ifExpression({ re, env, ref })
@@ -350,33 +330,24 @@ const resolveCondition = ({ rem, name, env, exp, errors }) => {
     default:
       if (env[ret[VALUE]]) setReturnRef(ref[STATS], env[ret[VALUE]][STATS])
       else
-        stack.push(() => {
+        stack.append(() => {
           if (env[ret[VALUE]]) setReturnRef(ref[STATS], env[ret[VALUE]][STATS])
         })
       break
   }
 }
-const resolveRetunType = ({
-  returns,
-  rem,
-  stack,
-  prop,
-  exp,
-  name,
-  errors,
-  env
-}) => {
+const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
   if (returns[TYPE] === ATOM) {
     // ATOM ASSIGMENT
     setPropToAtom(env[name][STATS], prop)
-    checkPredicateName(exp, [[WORD, name], returns], errors)
+    checkPredicateName(exp, [[WORD, name], returns])
   } else {
     switch (returns[VALUE]) {
       case KEYWORDS.IF:
-        resolveIfAssigment({ rem, name, env, exp, errors, prop })
+        resolveIfAssigment({ rem, name, env, exp, prop })
         break
       default:
-        checkPredicateNameDeep(name, exp, exp.slice(1), returns, errors)
+        checkPredicateNameDeep(name, exp, exp.slice(1), returns)
         if (!env[returns[VALUE]]) return false
         else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
           if (returns[TYPE] === WORD) setReturnToAbbstraction(env[name][STATS])
@@ -385,7 +356,7 @@ const resolveRetunType = ({
             // rest.at(-1)[0][TYPE] === APPLY
             // Here is upon application to store the result in the variable
             if (isUnknownType(env[name][STATS]))
-              stack.unshift(() => {
+              stack.prepend(() => {
                 setTypeToReturn(env[name][STATS], env[returns[VALUE]][STATS])
                 // env[name][STATS][TYPE_PROP][0] =
                 //   env[returns[VALUE]][STATS][RETURNS][0]
@@ -401,7 +372,7 @@ const resolveRetunType = ({
   }
   return true
 }
-const checkReturnType = ({ exp, stack, name, errors, env }) => {
+const checkReturnType = ({ exp, stack, name, env }) => {
   const last = exp.at(-1).at(-1)
   const body = hasApplyLambdaBlock(last) ? last.at(-1).at(-1) : last
   const rem = hasBlock(body) ? body.at(-1) : body
@@ -412,7 +383,6 @@ const checkReturnType = ({ exp, stack, name, errors, env }) => {
     prop: RETURNS,
     exp,
     name,
-    errors,
     env,
     stack
   })
@@ -420,9 +390,8 @@ const checkReturnType = ({ exp, stack, name, errors, env }) => {
 export const typeCheck = (ast, error = true) => {
   let scopeIndex = 0
   const root = structuredClone(SPECIAL_FORM_TYPES)
-  const errors = new Set()
   const Types = new Map()
-  const stack = []
+  const stack = new Brr()
   const check = (exp, env, scope) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first === undefined)
@@ -434,14 +403,14 @@ export const typeCheck = (ast, error = true) => {
     switch (first[TYPE]) {
       case WORD:
         if (!isSpecial)
-          stack.push(
-            () =>
-              // Figure out how to determine if varible is define after it's used
-              env[first[VALUE]] === undefined &&
-              errors.add(
+          stack.append(() => {
+            // Figure out how to determine if varible is define after it's used
+            if (env[first[VALUE]] === undefined) {
+              throw new TypeError(
                 `Trying to access undefined variable ${first[VALUE]} (check #11)`
               )
-          )
+            }
+          })
         break
       case ATOM:
         break
@@ -483,30 +452,28 @@ export const typeCheck = (ast, error = true) => {
                   stack,
                   exp,
                   env,
-                  name,
-                  errors
+                  name
                 }) ||
                 isUnknownReturn(env[name][STATS])
               ) {
-                retry(env[name][STATS], stack, errors, () => {
+                retry(env[name][STATS], stack, () => {
                   checkReturnType({
                     stack,
                     exp,
                     env,
-                    name,
-                    errors
+                    name
                   })
                   check(rightHand, env, exp)
                 })
                 check(rightHand, env, exp)
               } else check(rightHand, env, exp)
             } else {
-              checkPredicateName(exp, rest, errors)
+              checkPredicateName(exp, rest)
               const isLeafNode = isLeaf(rightHand)
               if (isLeafNode && rightHand[TYPE] === WORD) {
                 // TODO make sure this prevents the assigment all together
                 if (env[rest[1][VALUE]] === undefined)
-                  errors.add(
+                  throw new TypeError(
                     `Trying to access undefined variable ${rest[1][VALUE]} (check #22)`
                   )
                 // Used to be checkin if it's an assigment to a special form
@@ -555,8 +522,7 @@ export const typeCheck = (ast, error = true) => {
                   prop: TYPE_PROP,
                   exp,
                   env,
-                  name,
-                  errors
+                  name
                 })
               }
               check(rightHand, env, scope)
@@ -574,7 +540,7 @@ export const typeCheck = (ast, error = true) => {
               const param = params[i]
               // TODO move this somewhere else
               if (!isLeaf(param))
-                errors.add(
+                throw new TypeError(
                   `Invalid body for (${
                     first[VALUE]
                   }) if it takes more than one expression it must be wrapped in a (${
@@ -602,7 +568,7 @@ export const typeCheck = (ast, error = true) => {
                 // TODO figure out what we do here
                 // this here is a variable WORD
                 // so return type of that function is that varible type
-                stack.push(
+                stack.append(
                   () =>
                     copy[returns[VALUE]] &&
                     setReturnToType(ref[STATS], copy[returns[VALUE]][STATS])
@@ -617,7 +583,6 @@ export const typeCheck = (ast, error = true) => {
                       name: ref[STATS][SIGNATURE],
                       env: copy,
                       exp,
-                      errors,
                       stack
                     })
                     break
@@ -625,7 +590,7 @@ export const typeCheck = (ast, error = true) => {
                     if (copy[ret[VALUE]])
                       setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                     else
-                      stack.push(() => {
+                      stack.append(() => {
                         if (copy[ret[VALUE]])
                           setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                       })
@@ -655,9 +620,9 @@ export const typeCheck = (ast, error = true) => {
             }
             break
           default:
-            stack.push(() => {
+            stack.append(() => {
               if (!isSpecial && env[first[VALUE]] === undefined)
-                errors.add(
+                throw new TypeError(
                   `Trying to call undefined (lambda) ${first[VALUE]} (check #9)`
                 )
               else if (
@@ -665,7 +630,7 @@ export const typeCheck = (ast, error = true) => {
                 env[first[VALUE]][STATS][ARG_COUNT] !== VARIADIC &&
                 env[first[VALUE]][STATS][ARG_COUNT] !== rest.length
               )
-                errors.add(
+                throw new TypeError(
                   `Incorrect number of arguments for (${
                     first[VALUE]
                   }). Expected (= ${
@@ -675,7 +640,7 @@ export const typeCheck = (ast, error = true) => {
               else {
                 if (first[TYPE] === APPLY && !isSpecial) {
                   if (getType(env[first[VALUE]][STATS]) === ATOM)
-                    errors.add(
+                    throw new TypeError(
                       `(${first[VALUE]}) is not a (lambda) (${stringifyArgs(
                         exp
                       )}) (check #12)`
@@ -746,7 +711,7 @@ export const typeCheck = (ast, error = true) => {
                           const fnName = rest[i].at(-1)[VALUE]
                           const fn = env[fnName]
                           if (fn && getReturn(fn[STATS]) !== ATOM)
-                            errors.add(
+                            throw new TypeError(
                               `Incorrect type of argument (${i}) for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
@@ -761,7 +726,7 @@ export const typeCheck = (ast, error = true) => {
                           const returns = isLeaf(rem) ? rem : rem[0]
                           if (returns[TYPE] === ATOM) {
                             if (MAIN_TYPE !== ATOM)
-                              errors.add(
+                              throw new TypeError(
                                 `Incorrect type of argument ${i} for (${
                                   first[VALUE]
                                 }). Expected (${toTypeNames(
@@ -775,7 +740,7 @@ export const typeCheck = (ast, error = true) => {
                             !isUnknownReturn(env[returns[VALUE]][STATS]) &&
                             getReturn(env[returns[VALUE]][STATS]) !== ATOM
                           )
-                            errors.add(
+                            throw new TypeError(
                               `Incorrect type of argument ${i} for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
@@ -798,7 +763,7 @@ export const typeCheck = (ast, error = true) => {
                           env[name][STATS]
                         )
                       )
-                        errors.add(
+                        throw new TypeError(
                           `Incorrect type of argument (${i}) for special form (${
                             first[VALUE]
                           }). Expected (${toTypeNames(
@@ -838,7 +803,7 @@ export const typeCheck = (ast, error = true) => {
                                 env[name][STATS]
                               )
                             )
-                              errors.add(
+                              throw new TypeError(
                                 `Incorrect type of argument (${i}) for special form (${
                                   first[VALUE]
                                 }). Expected (${toTypeNames(
@@ -856,7 +821,7 @@ export const typeCheck = (ast, error = true) => {
                             rest[i][TYPE] !==
                             expectedArgs[i][STATS][TYPE_PROP][0]
                           )
-                            errors.add(
+                            throw new TypeError(
                               `Incorrect type of argument (${i}) for special form (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
@@ -883,7 +848,7 @@ export const typeCheck = (ast, error = true) => {
                       !isUnknownType(args[i][STATS]) &&
                       getType(args[i][STATS]) !== ATOM
                     ) {
-                      errors.add(
+                      throw new TypeError(
                         `Incorrect type of arguments ${i} for (${
                           first[VALUE]
                         }). Expected (${toTypeNames(
@@ -903,7 +868,7 @@ export const typeCheck = (ast, error = true) => {
                         env[rest[i][VALUE]][STATS][ARG_COUNT] !==
                         args[i][STATS][ARG_COUNT]
                       ) {
-                        errors.add(
+                        throw new TypeError(
                           `Incorrect number of arguments for (${
                             args[i][STATS][SIGNATURE]
                           }) the (lambda) argument of (${
@@ -927,7 +892,7 @@ export const typeCheck = (ast, error = true) => {
                             !isUnknownReturn(actual[STATS]) &&
                             !compareReturns(expected[STATS], actual[STATS])
                           ) {
-                            errors.add(
+                            throw new TypeError(
                               `Incorrect return type for (${
                                 expected[STATS][SIGNATURE]
                               }) the (lambda) argument of (${
@@ -938,8 +903,7 @@ export const typeCheck = (ast, error = true) => {
                                 getReturn(actual[STATS])
                               )}) (${stringifyArgs(exp)}) (check #782)`
                             )
-                          } else
-                            retry(actual[STATS], stack, errors, () => match1())
+                          } else retry(actual[STATS], stack, () => match1())
                         }
                         match1()
                         for (
@@ -956,7 +920,7 @@ export const typeCheck = (ast, error = true) => {
                               !isUnknownType(expected[STATS]) &&
                               !compareTypes(actual[STATS], expected[STATS])
                             )
-                              errors.add(
+                              throw new TypeError(
                                 `Incorrect type for (lambda) (${
                                   args[i][STATS][SIGNATURE]
                                 }) argument at position (${j}) named as (${
@@ -967,14 +931,7 @@ export const typeCheck = (ast, error = true) => {
                                   getType(actual[STATS])
                                 )}) (${stringifyArgs(exp)}) (check #781)`
                               )
-                            else
-                              retry(
-                                actual[STATS],
-                                stack,
-                                errors,
-
-                                () => match2()
-                              )
+                            else retry(actual[STATS], stack, () => match2())
                           }
                           match2()
                         }
@@ -987,7 +944,7 @@ export const typeCheck = (ast, error = true) => {
                       !isUnknownType(args[i][STATS]) &&
                       !compareTypes(env[rest[i][VALUE]][STATS], args[i][STATS])
                     ) {
-                      errors.add(
+                      throw new TypeError(
                         `Incorrect type of arguments ${i} for (${
                           first[VALUE]
                         }). Expected (${toTypeNames(
@@ -997,9 +954,7 @@ export const typeCheck = (ast, error = true) => {
                         )}) (check #30)`
                       )
                     } else if (isUnknownType(args[i][STATS]))
-                      retry(args[i][STATS], stack, errors, () =>
-                        check(exp, env, scope)
-                      )
+                      retry(args[i][STATS], stack, () => check(exp, env, scope))
                     else if (
                       env[rest[i][VALUE]] &&
                       !isUnknownType(args[i][STATS]) &&
@@ -1016,10 +971,10 @@ export const typeCheck = (ast, error = true) => {
                     const match = () => {
                       const actual = env[rest[i][0][VALUE]][STATS]
                       const expected = args[i][STATS]
-                      retryArgs(args[i][STATS], stack, errors, () => match())
+                      retryArgs(args[i][STATS], stack, () => match())
                       if (!isUnknownType(expected) && !isUnknownReturn(actual))
                         if (!compareTypeWithReturn(expected, actual))
-                          errors.add(
+                          throw new TypeError(
                             `Incorrect type of arguments ${i} for (${
                               first[VALUE]
                             }). Expected (${toTypeNames(
@@ -1039,7 +994,7 @@ export const typeCheck = (ast, error = true) => {
                                   KEYWORDS.ANONYMOUS_FUNCTION
                                 ) {
                                   if (argsN !== args[i][STATS][ARG_COUNT])
-                                    errors.add(
+                                    throw new TypeError(
                                       `Incorrect number of arguments for (${
                                         args[i][STATS][SIGNATURE]
                                       }) the (lambda) argument of (${
@@ -1077,7 +1032,7 @@ export const typeCheck = (ast, error = true) => {
                                           actual[STATS]
                                         )
                                       )
-                                        errors.add(
+                                        throw new TypeError(
                                           `Incorrect return type for (${
                                             expected[STATS][SIGNATURE]
                                           }) the (lambda) argument of (${
@@ -1091,12 +1046,8 @@ export const typeCheck = (ast, error = true) => {
                                           )}) (check #779)`
                                         )
                                       else
-                                        retry(
-                                          actual[STATS],
-                                          stack,
-                                          errors,
-
-                                          () => match1()
+                                        retry(actual[STATS], stack, () =>
+                                          match1()
                                         )
                                     }
                                     match1()
@@ -1118,7 +1069,7 @@ export const typeCheck = (ast, error = true) => {
                                             expected[STATS]
                                           )
                                         )
-                                          errors.add(
+                                          throw new TypeError(
                                             `Incorrect type for (lambda) (${
                                               args[i][STATS][SIGNATURE]
                                             }) argument at position (${j}) named as (${
@@ -1134,12 +1085,8 @@ export const typeCheck = (ast, error = true) => {
                                             )}) (check #780)`
                                           )
                                         else
-                                          retry(
-                                            actual[STATS],
-                                            stack,
-                                            errors,
-
-                                            () => match2()
+                                          retry(actual[STATS], stack, () =>
+                                            match2()
                                           )
                                       }
                                       match2()
@@ -1156,7 +1103,7 @@ export const typeCheck = (ast, error = true) => {
                           }
                         }
                       else if (isUnknownType(expected))
-                        retry(args[i][STATS], stack, errors, () => match())
+                        retry(args[i][STATS], stack, () => match())
                     }
                     match()
                   }
@@ -1168,7 +1115,7 @@ export const typeCheck = (ast, error = true) => {
               const r = rest[i]
               if (isLeaf(r) && r[TYPE] !== ATOM)
                 if (env[r[VALUE]] == undefined)
-                  errors.add(
+                  throw new TypeError(
                     `(${
                       first[VALUE]
                     }) is trying to access undefined variable (${
@@ -1184,8 +1131,7 @@ export const typeCheck = (ast, error = true) => {
   }
   const copy = JSON.parse(JSON.stringify(ast))
   check(copy, root, copy)
-  while (stack.length) stack.pop()()
-  if (error && errors.size) throw new TypeError([...errors.values()].join('\n'))
+  while (stack.length) stack.cut()()
   return [ast, Types]
 }
 export const type = (ast) => typeCheck(ast)[0]