fez-lisp 1.5.154 → 1.5.156

package/package.json

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

package/src/check.js

@@ -45,9 +45,7 @@ import {
   BOOLEAN,
   IS_ARGUMENT,
   NUMBER,
-  SETTER,
-  NUMBER_SUBTYPE,
-  GENERIC
+  NUMBER_SUBTYPE
 } from './types.js'
 import {
   Brr,
@@ -327,17 +325,6 @@ const IsPredicate = (leaf) =>
     (PREDICATES_OUTPUT_SET.has(leaf[VALUE]) ||
       getSuffix(leaf[VALUE]) === PREDICATE_SUFFIX))
 
-// THese should also check if sub type is Uknown array and pass as ok
-const notABooleanType = (a, b) => {
-  return (
-    hasSubType(a) &&
-    getSubType(a).has(BOOLEAN) &&
-    !isUnknownType(b) &&
-    !isAnyType(b) &&
-    ((!hasSubType(b) && getType(b) !== COLLECTION) ||
-      (hasSubType(b) && getSubType(a).difference(getSubType(b)).size !== 0))
-  )
-}
 const equalSubTypes = (a, b) => {
   return (
     !hasSubType(a) ||
@@ -371,24 +358,6 @@ const equalSubTypesWithSubReturn = (a, b) => {
     getSubType(a).difference(getSubReturn(b)).size === 0
   )
 }
-const notABooleanTypeWithReturn = (a, b) => {
-  return (
-    hasSubType(a) &&
-    getSubType(a).has(BOOLEAN) &&
-    !isUnknownReturn(b) &&
-    !isAnyReturn(b) &&
-    (!hasSubReturn(b) || getSubType(a).difference(getSubReturn(b)).size !== 0)
-  )
-}
-const notABooleanReturn = (a, b) => {
-  return (
-    hasSubReturn(a) &&
-    getSubReturn(a).has(BOOLEAN) &&
-    !isUnknownReturn(b) &&
-    !isAnyReturn(b) &&
-    (!hasSubReturn(b) || getSubReturn(a).difference(getSubReturn(b)).size !== 0)
-  )
-}
 const isAtomABoolean = (atom) => atom === TRUE || atom === FALSE
 const checkPredicateName = (exp, rest) => {
   if (getSuffix(rest[0][VALUE]) === PREDICATE_SUFFIX) {
@@ -491,14 +460,27 @@ const retryArgs = (stats, ctx, stack, cb) => {
     stagger(stack, 'prepend', ctx, cb)
   }
 }
-const IfApplyBranch = ({ leaf, branch, re, prop, ref, env }) => {
+const IfApplyBranch = ({
+  leaf,
+  branch,
+  re,
+  prop,
+  ref,
+  env,
+  stack,
+  exp,
+  check
+}) => {
   switch (leaf[VALUE]) {
     case KEYWORDS.IF:
       return ifExpression({
         re: re.slice(2),
         env,
         ref,
-        prop
+        prop,
+        stack,
+        exp,
+        check
       })
     case KEYWORDS.CREATE_ARRAY:
       setPropToReturnRef(ref[STATS], prop, initArrayType({ rem: re, env }))
@@ -522,7 +504,9 @@ const IfApplyBranch = ({ leaf, branch, re, prop, ref, env }) => {
             env,
             prop,
             leaf: re.at(-1),
-            re: re.at(-1).slice(2)
+            re: re.at(-1).slice(2),
+            stack,
+            exp
           })
       }
       break
@@ -530,7 +514,7 @@ const IfApplyBranch = ({ leaf, branch, re, prop, ref, env }) => {
       return setPropToReturnRef(ref[STATS], prop, branch[STATS])
   }
 }
-const ifExpression = ({ re, env, ref, prop }) => {
+const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
   if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM)
     return setPropToAtom(ref[STATS], prop)
   // TODO check that both brancehs are predicates if one is
@@ -539,6 +523,7 @@ const ifExpression = ({ re, env, ref, prop }) => {
     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)
@@ -556,7 +541,10 @@ const ifExpression = ({ re, env, ref, prop }) => {
           re: re[0],
           prop,
           env,
-          ref
+          ref,
+          stack,
+          exp,
+          check
         })
       }
     if (alternative) {
@@ -574,13 +562,16 @@ const ifExpression = ({ re, env, ref, prop }) => {
           re: re[1],
           prop,
           env,
-          ref
+          ref,
+          stack,
+          exp,
+          check
         })
       }
     }
   }
 }
-const resolveCondition = ({ rem, name, env, exp, prop }) => {
+const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
   const ret = rem[0]
   const re = rem.slice(2)
   const ref = env[name]
@@ -588,7 +579,7 @@ const resolveCondition = ({ rem, name, env, exp, prop }) => {
   checkPredicateName(exp, [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]])
   switch (ret[VALUE]) {
     case KEYWORDS.IF:
-      ifExpression({ re, env, ref, prop })
+      ifExpression({ re, env, ref, prop, exp, stack, check })
       break
     default:
       if (env[ret[VALUE]]) setPropRef(ref[STATS], prop, env[ret[VALUE]][STATS])
@@ -651,7 +642,7 @@ const resolveSetter = (first, rest, env, stack) => {
               getSubType(env[right[VALUE]][STATS])
             )
           } else
-            retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
+            once(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
               resolveSetter(first, rest, env, stack)
             )
         }
@@ -688,19 +679,20 @@ const resolveSetter = (first, rest, env, stack) => {
             current[STATS][TYPE_PROP][1] = new Set([
               ...getSubReturn(env[right[VALUE]][STATS])
             ])
-          } else
-            retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
-              resolveSetter(first, rest, env, stack)
-            )
+          }
+          // else
+          // retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
+          //   resolveSetter(first, rest, env, stack)
+          // )
         }
         break
     }
     setTypeToCollection(current[STATS])
-    // Retry setting the sub-type if infered it out later
-    if (!hasSubType(current[STATS]) || getSubType(current[STATS]).has(UNKNOWN))
-      retry(current[STATS], [first[VALUE], rest], stack, () =>
-        resolveSetter(first, rest, env, stack)
-      )
+    // // Retry setting the sub-type if infered it out later
+    // if (!hasSubType(current[STATS]) || getSubType(current[STATS]).has(UNKNOWN))
+    //   retry(current[STATS], [first[VALUE], rest], stack, () =>
+    //     resolveSetter(first, rest, env, stack)
+    //   )
   }
 }
 const resolveGetter = ({ rem, prop, name, env }) => {
@@ -787,7 +779,7 @@ const resolveReturnType = ({
         setPropToSubReturn(env[name][STATS], prop, initArrayType({ rem, env }))
         break
       case KEYWORDS.IF:
-        resolveCondition({ rem, name, env, exp, prop })
+        resolveCondition({ rem, name, env, exp, prop, stack, check })
         break
       default:
         {
@@ -795,7 +787,7 @@ const resolveReturnType = ({
             GETTERS_SET.has(returns[VALUE]) &&
             !resolveGetter({ rem, prop, name, env })
           )
-            return retry(env[name][STATS], [returns, env], stack, () => {
+            return once(env[name][STATS], [returns, env], stack, () => {
               resolveReturnType({
                 returns,
                 rem,
@@ -824,7 +816,6 @@ const resolveReturnType = ({
               // ALWAYS APPLY
               // rest.at(-1)[0][TYPE] === APPLY
               // Here is upon application to store the result in the variable
-
               if (isUnknownType(env[name][STATS]))
                 stagger(stack, 'prepend', exp, () => {
                   if (isGenericReturn(env[returns[VALUE]][STATS])) {
@@ -1020,7 +1011,7 @@ export const typeCheck = (ast) => {
                           getReturn(actual[STATS])
                         )}) (${stringifyArgs(exp)}) (check #779)`
                       )
-                    else if (notABooleanReturn(expected[STATS], actual[STATS]))
+                    else if (!eualSubReturn(expected[STATS], actual[STATS]))
                       throw new TypeError(
                         `Incorrect return type for (${
                           expected[STATS][SIGNATURE]
@@ -1033,7 +1024,7 @@ export const typeCheck = (ast) => {
                         )}) (${stringifyArgs(exp)}) (check #783)`
                       )
                     else
-                      retry(
+                      once(
                         actual[STATS],
                         [[WORD, lambdaName], local],
                         stack,
@@ -1042,54 +1033,45 @@ export const typeCheck = (ast) => {
                   }
                   match1()
                   for (let j = 0; j < args[i][STATS][ARGUMENTS].length; ++j) {
-                    const match2 = () => {
-                      const actual = local[lambdaName][STATS][ARGUMENTS][j]
-                      const expected = args[i][STATS][ARGUMENTS][j]
-                      if (
-                        !isUnknownType(actual[STATS]) &&
-                        !isUnknownType(expected[STATS]) &&
-                        !equalTypes(actual[STATS], expected[STATS])
+                    const actual = local[lambdaName][STATS][ARGUMENTS][j]
+                    const expected = args[i][STATS][ARGUMENTS][j]
+                    if (
+                      !isUnknownType(actual[STATS]) &&
+                      !isUnknownType(expected[STATS]) &&
+                      !equalTypes(actual[STATS], expected[STATS])
+                    )
+                      throw new TypeError(
+                        `Incorrect type for (${KEYWORDS.ANONYMOUS_FUNCTION}) (${
+                          args[i][STATS][SIGNATURE]
+                        }) argument at position (${j}) named as (${
+                          local[lambdaName][STATS][ARGUMENTS][j][STATS][
+                            SIGNATURE
+                          ]
+                        }). Expected (${toTypeNames(
+                          getType(expected[STATS])
+                        )}) but got (${toTypeNames(
+                          getType(actual[STATS])
+                        )}) (${stringifyArgs(exp)}) (check #780)`
                       )
-                        throw new TypeError(
-                          `Incorrect type for (${
-                            KEYWORDS.ANONYMOUS_FUNCTION
-                          }) (${
-                            args[i][STATS][SIGNATURE]
-                          }) argument at position (${j}) named as (${
-                            local[lambdaName][STATS][ARGUMENTS][j][STATS][
-                              SIGNATURE
-                            ]
-                          }). Expected (${toTypeNames(
-                            getType(expected[STATS])
-                          )}) but got (${toTypeNames(
-                            getType(actual[STATS])
-                          )}) (${stringifyArgs(exp)}) (check #780)`
-                        )
-                      else if (
-                        notABooleanReturn(expected[STATS], actual[STATS])
+                    else if (!eualSubReturn(expected[STATS], actual[STATS]))
+                      throw new TypeError(
+                        `Incorrect return type for (${
+                          expected[STATS][SIGNATURE]
+                        }) the (${KEYWORDS.ANONYMOUS_FUNCTION}) argument of (${
+                          first[VALUE]
+                        }) at position (${i}). Expected (${toTypeNames(
+                          getReturn(expected[STATS])
+                        )}) but got (${toTypeNames(
+                          getReturn(actual[STATS])
+                        )}) (${stringifyArgs(exp)}) (check #784)`
                       )
-                        throw new TypeError(
-                          `Incorrect return type for (${
-                            expected[STATS][SIGNATURE]
-                          }) the (${
-                            KEYWORDS.ANONYMOUS_FUNCTION
-                          }) argument of (${
-                            first[VALUE]
-                          }) at position (${i}). Expected (${toTypeNames(
-                            getReturn(expected[STATS])
-                          )}) but got (${toTypeNames(
-                            getReturn(actual[STATS])
-                          )}) (${stringifyArgs(exp)}) (check #784)`
-                        )
-                      else
-                        retry(
-                          actual[STATS],
-                          [[WORD, lambdaName], local],
-                          stack,
-                          match2
-                        )
-                    }
-                    match2()
+                    // else
+                    //   retry(
+                    //     actual[STATS],
+                    //     [[WORD, lambdaName], local],
+                    //     stack,
+                    //     match2
+                    //   )
                   }
                 }
               } else {
@@ -1281,11 +1263,11 @@ export const typeCheck = (ast) => {
                   [TYPE_PROP]: [UNKNOWN],
                   [RETURNS]: [UNKNOWN],
                   [ARGUMENTS]: [],
+                  argIndex: i,
                   retried: 0,
                   counter: 0
                 }
               }
-
               const ref = env[copy[SCOPE_NAME]]
               if (!ref) continue
               ref[STATS][ARGUMENTS][i] = copy[param[VALUE]]
@@ -1320,7 +1302,8 @@ export const typeCheck = (ast) => {
                         env: copy,
                         exp,
                         stack,
-                        prop: RETURNS
+                        prop: RETURNS,
+                        check
                       })
                       break
                     default:
@@ -1584,76 +1567,6 @@ export const typeCheck = (ast) => {
                                   )
                               }
                             }
-                            // DEFINED  LAMBDAS TYPE CHECKING
-                            // #C1
-                            // TODO delete this maybe
-                            // It will not be possilbe to know return type
-                            const match1 = () => {
-                              const actual = env[name]
-                              const expected = args[i]
-                              if (
-                                !isUnknownReturn(expected[STATS]) &&
-                                !isUnknownReturn(actual[STATS]) &&
-                                !equalReturns(expected[STATS], actual[STATS])
-                              ) {
-                                throw new TypeError(
-                                  `Incorrect return type for (${
-                                    expected[STATS][SIGNATURE]
-                                  }) the (${
-                                    KEYWORDS.ANONYMOUS_FUNCTION
-                                  }) argument of (${
-                                    first[VALUE]
-                                  }) at position (${i}). Expected (${toTypeNames(
-                                    getReturn(expected[STATS])
-                                  )}) but got (${toTypeNames(
-                                    getReturn(actual[STATS])
-                                  )}) (${stringifyArgs(exp)}) (check #782)`
-                                )
-                              } else
-                                retry(
-                                  actual[STATS],
-                                  [first, env],
-                                  stack,
-                                  match1
-                                )
-                            }
-                            match1()
-                            for (
-                              let j = 0;
-                              j < args[i][STATS][ARGUMENTS].length;
-                              ++j
-                            ) {
-                              const match2 = () => {
-                                const actual = env[name][STATS][ARGUMENTS][j]
-                                const expected = args[i][STATS][ARGUMENTS][j]
-                                if (
-                                  !isUnknownType(actual[STATS]) &&
-                                  !isUnknownType(expected[STATS]) &&
-                                  !equalTypes(actual[STATS], expected[STATS])
-                                )
-                                  throw new TypeError(
-                                    `Incorrect type for (${
-                                      KEYWORDS.ANONYMOUS_FUNCTION
-                                    }) (${
-                                      args[i][STATS][SIGNATURE]
-                                    }) argument at position (${j}) named as (${
-                                      actual[STATS][SIGNATURE]
-                                    }). Expected (${toTypeNames(
-                                      getType(expected[STATS])
-                                    )}) but got (${toTypeNames(
-                                      getType(actual[STATS])
-                                    )}) (${stringifyArgs(exp)}) (check #781)`
-                                  )
-                                else
-                                  retry(
-                                    actual[STATS],
-                                    [first, env],
-                                    stack,
-                                    match2
-                                  )
-                              }
-                              match2()
-                            }
                           }
                           break
                       }

package/src/types.js

@@ -24,7 +24,7 @@ export const NUMBER = 6
 export const ANY = 4
 export const GENERIC = 7
 export const ANONYMOUS_FUNCTION_TYPE_PREFIX = 'lambda::annonymous::'
-export const MAX_ARGUMENT_RETRY = 1
+export const MAX_ARGUMENT_RETRY = 3
 export const MAX_RETRY_DEFINITION = 50
 export const IS_ARGUMENT = 'is_arg'
 export const NIL = 'nil'