fez-lisp 1.5.99 → 1.5.101

package/logo.svg

@@ -1,5 +1,5 @@
-<svg width="61" height="79" viewBox="0 0 61 79" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M58.8257 55.7684C63.4688 62.5468 57.2431 75.2357 42.5 78C34.5 79.5 2.00013 79.4982 2 64.3957C1.99984 45.77 28.6339 50.3503 39.5543 55.7684C56.8985 61.3234 54.329 49.2038 58.8257 55.7684Z" fill="#F9B949"/>
+<svg width="60" height="88" viewBox="0 0 60 88" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M56 58.4998C61.166 60.9107 63.7232 82.5984 43 86.4999C31.755 88.617 1.50018 90.3154 1.5 69C1.49978 42.7121 27.65 50.8529 43 58.4998C52 61 50.834 56.089 56 58.4998Z" fill="#F9B949"/>
 <circle cx="25.5" cy="35.5" r="25.5" fill="#F9B949"/>
 <circle cx="36.5" cy="31.5" r="2.5" fill="#1F1B1B"/>
 <circle cx="9.5" cy="21.5" r="2.5" fill="#1F1B1B"/>
@@ -9,8 +9,8 @@
 <circle cx="37" cy="31" r="1" fill="#EBEBEB"/>
 <circle cx="37" cy="31" r="1" fill="#EBEBEB"/>
 <circle cx="37" cy="31" r="1" fill="#EBEBEB"/>
-<path d="M11.6564 26.818C17.5013 31.4502 17.7946 23.2377 23.0134 28.6252C28.2321 34.0127 30.2289 37.3689 19.8597 35.7179C9.49045 34.0669 5.8115 22.1858 11.6564 26.818Z" fill="#B44637"/>
-<path d="M49.8808 7.37404C50.5137 5.27388 40.491 0.514532 39.3766 1.22816C38.2623 1.94179 33.2308 11.7323 33.2308 11.7323L43.7349 17.8782C43.7349 17.8782 49.2479 9.47421 49.8808 7.37404Z" fill="#B44637"/>
-<path d="M49.8808 7.37404C50.5137 5.27388 40.491 0.514532 39.3766 1.22816C38.2623 1.94179 33.2308 11.7323 33.2308 11.7323L43.7349 17.8782C43.7349 17.8782 49.2479 9.47421 49.8808 7.37404Z" fill="#B44637"/>
+<path d="M49.8808 7.37404C50.5137 5.27388 40.491 0.514532 39.3766 1.22816C38.2623 1.9418 33.2308 11.7323 33.2308 11.7323L43.7349 17.8782C43.7349 17.8782 49.2479 9.47421 49.8808 7.37404Z" fill="#B44637"/>
+<path d="M49.8808 7.37404C50.5137 5.27388 40.491 0.514532 39.3766 1.22816C38.2623 1.9418 33.2308 11.7323 33.2308 11.7323L43.7349 17.8782C43.7349 17.8782 49.2479 9.47421 49.8808 7.37404Z" fill="#B44637"/>
 <path d="M51 15C46 13.5 54.6472 7.06417 48.8171 5" stroke="#F9B949" stroke-width="2" stroke-linecap="round"/>
+<path d="M19.5 27.1883C16.1667 26.3396 12 28.635 12 28.635C12 28.635 12.4167 30.7565 17.4167 32.7045C22.4167 34.6525 27 35 27 35C27 35 22.8333 28.037 19.5 27.1883Z" fill="#B44637"/>
 </svg>

package/package.json

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

package/src/check.js

@@ -66,6 +66,10 @@ const deepLambdaReturn = (rest, condition) => {
   const rem = hasBlock(body) ? body.at(-1) : body
   return condition(rem) ? rem : deepLambdaReturn(rem, condition)
 }
+export const isUnknownNotAnyType = (stats) =>
+  stats && !isAnyType(stats) && isUnknownType(stats)
+export const isUnknownNotAnyReturn = (stats) =>
+  stats && !isAnyReturn(stats) && isUnknownReturn(stats)
 export const castType = (stats, type) =>
   (stats[TYPE_PROP][0] = type[RETURNS][0])
 export const castReturn = (stats, type) =>
@@ -234,7 +238,22 @@ const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
   return `${chain.length === 1 ? '; ' : ''}${chain.join(' ')} ${name}`
 }
-
+const retry = (stats, stack, errors, cb) => {
+  if (
+    errors.size === 0 &&
+    (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
+    stats.retried < MAX_RETRY_DEFINITION
+  ) {
+    stats.retried += 1
+    stack.unshift(() => cb())
+  }
+}
+const retryArgs = (stats, stack, errors, cb) => {
+  if (errors.size === 0 && stats.counter < MAX_ARGUMENT_RETRY) {
+    stats.counter++
+    stack.unshift(cb)
+  }
+}
 const ifExpression = ({ re, env, ref }) => {
   if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM) setReturnToAtom(ref[STATS])
   // TODO check that both brancehs are predicates if one is
@@ -259,6 +278,19 @@ const ifExpression = ({ re, env, ref }) => {
     }
   }
 }
+const resolveApplyAssigment = (re, name, env) => {
+  if (re[0][TYPE] === APPLY) {
+    switch (re[0][VALUE]) {
+      case KEYWORDS.ANONYMOUS_FUNCTION:
+        // FN ASSIGMENT
+        env[name][STATS][TYPE_PROP] = [APPLY]
+        env[name][STATS][RETURNS] = [UNKNOWN]
+        env[name][STATS][ARG_COUNT] = re.length - 2
+        env[name][STATS][ARGUMENTS] = fillUknownArgs(re.length - 2)
+        break
+    }
+  }
+}
 const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
   const re = rem.slice(2)
   checkPredicateName(
@@ -280,17 +312,7 @@ const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
     !isUnknownReturn(env[re[0][0][VALUE]][STATS])
   ) {
     setPropToReturnRef(env[name][STATS], prop, env[re[0][0][VALUE]][STATS])
-    if (re[0][0][TYPE] === APPLY) {
-      switch (re[0][0][VALUE]) {
-        case KEYWORDS.ANONYMOUS_FUNCTION:
-          // FN UKNONW ASSIGMENT
-          env[name][STATS][TYPE_PROP] = [APPLY]
-          env[name][STATS][RETURNS] = [UNKNOWN]
-          env[name][STATS][ARG_COUNT] = re[0].length - 2
-          env[name][STATS][ARGUMENTS] = fillUknownArgs(re[0].length - 2)
-          break
-      }
-    }
+    resolveApplyAssigment(re[0], name, env)
     // env[name][STATS] = env[re[0][0][VALUE]][STATS]
   } else if (
     !isLeaf(re[1]) &&
@@ -298,17 +320,7 @@ const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
     !isUnknownReturn(env[re[1][0][VALUE]][STATS])
   ) {
     setPropToReturnRef(env[name][STATS], prop, env[re[1][0][VALUE]][STATS])
-    if (re[1][0][TYPE] === APPLY) {
-      switch (re[1][0][VALUE]) {
-        case KEYWORDS.ANONYMOUS_FUNCTION:
-          // FN ASSIGMENT
-          env[name][STATS][TYPE_PROP] = [APPLY]
-          env[name][STATS][RETURNS] = [UNKNOWN]
-          env[name][STATS][ARG_COUNT] = re[1].length - 2
-          env[name][STATS][ARGUMENTS] = fillUknownArgs(re[1].length - 2)
-          break
-      }
-    }
+    resolveApplyAssigment(re[1], name, env)
   } else if (env[re[0][VALUE]])
     // ASSIGMENT
     setPropRef(env[name][STATS], prop, env[re[0][VALUE]][STATS])
@@ -319,6 +331,7 @@ const resolveIfAssigment = ({ rem, name, env, exp, errors, prop }) => {
 const resolveCondition = ({ rem, name, env, exp, errors }) => {
   const ret = rem[0]
   const re = rem.slice(2)
+  resolveApplyAssigment(re, name, env)
   const ref = env[name]
   checkPredicateName(
     exp,
@@ -443,117 +456,112 @@ export const typeCheck = (ast, error = true) => {
                   exp
                 )})`
               )
-            else {
-              const name = rest[0][VALUE]
-              //  Predicate name consistency
-              const rightHand = rest.at(-1)
+            const name = rest[0][VALUE]
+            //  Predicate name consistency
+            const rightHand = rest.at(-1)
+            if (
+              rightHand &&
+              rightHand[0] &&
+              rightHand[0][TYPE] === APPLY &&
+              rightHand[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+            ) {
+              validateLambda(rightHand, name)
+              const n = rightHand.length
+              env[name] = {
+                [STATS]: {
+                  [TYPE_PROP]: [APPLY],
+                  [SIGNATURE]: name,
+                  retried: 0,
+                  counter: 0,
+                  [ARG_COUNT]: n - 2,
+                  [ARGUMENTS]: fillUknownArgs(n - 2),
+                  [RETURNS]: [UNKNOWN]
+                }
+              }
               if (
-                rightHand &&
-                rightHand[0] &&
-                rightHand[0][TYPE] === APPLY &&
-                rightHand[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
+                !checkReturnType({
+                  stack,
+                  exp,
+                  env,
+                  name,
+                  errors
+                }) ||
+                isUnknownReturn(env[name][STATS])
               ) {
-                validateLambda(rightHand, name)
-                const n = rightHand.length
-                env[name] = {
-                  [STATS]: {
-                    [TYPE_PROP]: [APPLY],
-                    [SIGNATURE]: name,
-                    retried: 0,
-                    counter: 0,
-                    [ARG_COUNT]: n - 2,
-                    [ARGUMENTS]: fillUknownArgs(n - 2),
-                    [RETURNS]: [UNKNOWN]
-                  }
-                }
-                if (
-                  !checkReturnType({
+                retry(env[name][STATS], stack, errors, () => {
+                  checkReturnType({
                     stack,
                     exp,
                     env,
                     name,
                     errors
-                  }) ||
-                  (isUnknownReturn(env[name][STATS]) &&
-                    env[name][STATS].retried < MAX_RETRY_DEFINITION)
-                ) {
-                  env[name][STATS].retried += 1
-                  stack.unshift(() => {
-                    checkReturnType({
-                      stack,
-                      exp,
-                      env,
-                      name,
-                      errors
-                    })
-                    check(rightHand, env, exp)
                   })
                   check(rightHand, env, exp)
-                } else check(rightHand, env, exp)
-              } else {
-                checkPredicateName(exp, rest, errors)
-                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(
-                      `Trying to access undefined variable ${rest[1][VALUE]} (check #22)`
-                    )
-
-                  // Used to be checkin if it's an assigment to a special form
-                  // but this should not cause problems
-                  // env[name] = SPECIAL_FORMS_SET.has(rest[1][VALUE])
-                  //   ? structuredClone(env[rest[1][VALUE]])
-                  //   : env[rest[1][VALUE]]
-                  // FULL REFF ASSIGMENT
-                  env[name] = env[rest[1][VALUE]]
-                } else if (isLeafNode && rightHand[TYPE] === ATOM) {
-                  // DECLARATION of ATOM
-                  env[name] = {
-                    [STATS]: {
-                      [SIGNATURE]: name,
-                      retried: 0,
-                      counter: 0,
-                      [TYPE_PROP]: [ATOM],
-                      [RETURNS]: [ATOM]
-                    }
+                })
+                check(rightHand, env, exp)
+              } else check(rightHand, env, exp)
+            } else {
+              checkPredicateName(exp, rest, errors)
+              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(
+                    `Trying to access undefined variable ${rest[1][VALUE]} (check #22)`
+                  )
+                // Used to be checkin if it's an assigment to a special form
+                // but this should not cause problems
+                // env[name] = SPECIAL_FORMS_SET.has(rest[1][VALUE])
+                //   ? structuredClone(env[rest[1][VALUE]])
+                //   : env[rest[1][VALUE]]
+                // FULL REFF ASSIGMENT
+                env[name] = env[rest[1][VALUE]]
+              } else if (isLeafNode && rightHand[TYPE] === ATOM) {
+                // DECLARATION of ATOM
+                env[name] = {
+                  [STATS]: {
+                    [SIGNATURE]: name,
+                    retried: 0,
+                    counter: 0,
+                    [TYPE_PROP]: [ATOM],
+                    [RETURNS]: [ATOM]
                   }
-                } else if (rightHand[0]) {
-                  const right = rightHand[0]
-                  //DECLARATION
-                  env[name] = {
-                    [STATS]: {
-                      retried: 0,
-                      counter: 0,
-                      [SIGNATURE]: name,
-                      [TYPE_PROP]: [
-                        isLeafNode
-                          ? right[TYPE]
-                          : env[right[VALUE]] == undefined
-                          ? UNKNOWN
-                          : env[right[VALUE]][STATS][RETURNS][0]
-                      ],
-                      [RETURNS]: [UNKNOWN]
-                    }
+                }
+              } else if (rightHand[0]) {
+                const right = rightHand[0]
+                // DECLARATION
+                env[name] = {
+                  [STATS]: {
+                    retried: 0,
+                    counter: 0,
+                    [SIGNATURE]: name,
+                    [TYPE_PROP]: [
+                      isLeafNode
+                        ? right[TYPE]
+                        : env[right[VALUE]] == undefined
+                        ? UNKNOWN
+                        : env[right[VALUE]][STATS][RETURNS][0]
+                    ],
+                    [RETURNS]: [UNKNOWN]
                   }
-                  const body = rightHand
-                  const rem = hasBlock(body) ? body.at(-1) : body
-                  const returns = isLeaf(rem) ? rem : rem[0]
-                  resolveRetunType({
-                    stack,
-                    returns,
-                    rem,
-                    prop: TYPE_PROP,
-                    exp,
-                    env,
-                    name,
-                    errors
-                  })
                 }
-                check(rightHand, env, scope)
+                const body = rightHand
+                const rem = hasBlock(body) ? body.at(-1) : body
+                const returns = isLeaf(rem) ? rem : rem[0]
+                resolveRetunType({
+                  stack,
+                  returns,
+                  rem,
+                  prop: TYPE_PROP,
+                  exp,
+                  env,
+                  name,
+                  errors
+                })
               }
-              Types.set(withScope(name, env), () => formatType(name, env))
+              check(rightHand, env, scope)
             }
+            Types.set(withScope(name, env), () => formatType(name, env))
             break
           case KEYWORDS.ANONYMOUS_FUNCTION:
             validateLambda(exp)
@@ -621,7 +629,6 @@ export const typeCheck = (ast, error = true) => {
                         if (copy[ret[VALUE]])
                           setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                       })
-
                     break
                 }
               }
@@ -931,12 +938,8 @@ export const typeCheck = (ast, error = true) => {
                                 getReturn(actual[STATS])
                               )}) (${stringifyArgs(exp)}) (check #782)`
                             )
-                          } else if (
-                            actual[STATS].retried < MAX_RETRY_DEFINITION
-                          ) {
-                            actual[STATS].retried += 1
-                            stack.unshift(() => match1())
-                          }
+                          } else
+                            retry(actual[STATS], stack, errors, () => match1())
                         }
                         match1()
                         for (
@@ -964,12 +967,14 @@ export const typeCheck = (ast, error = true) => {
                                   getType(actual[STATS])
                                 )}) (${stringifyArgs(exp)}) (check #781)`
                               )
-                            else if (
-                              actual[STATS].retried < MAX_RETRY_DEFINITION
-                            ) {
-                              actual[STATS].retried += 1
-                              stack.unshift(() => match2())
-                            }
+                            else
+                              retry(
+                                actual[STATS],
+                                stack,
+                                errors,
+
+                                () => match2()
+                              )
                           }
                           match2()
                         }
@@ -991,34 +996,27 @@ export const typeCheck = (ast, error = true) => {
                           exp
                         )}) (check #30)`
                       )
-                    } else if (
-                      isUnknownType(args[i][STATS]) &&
-                      args[i][STATS].retried < MAX_RETRY_DEFINITION
+                    } else if (isUnknownType(args[i][STATS]))
+                      retry(args[i][STATS], stack, errors, () =>
+                        check(exp, env, scope)
+                      )
+                    else if (
+                      env[rest[i][VALUE]] &&
+                      !isUnknownType(args[i][STATS]) &&
+                      isUnknownType(env[rest[i][VALUE]][STATS]) &&
+                      getType(args[i][STATS]) !== APPLY
                     ) {
-                      args[i][STATS].retried += 1
-                      stack.unshift(() => check(exp, env, scope))
-                    } else {
-                      if (
-                        env[rest[i][VALUE]] &&
-                        !isUnknownType(args[i][STATS]) &&
-                        isUnknownType(env[rest[i][VALUE]][STATS]) &&
-                        getType(args[i][STATS]) !== APPLY
-                      ) {
-                        // REFF ASSIGMENT
-                        env[rest[i][VALUE]][STATS][TYPE_PROP] =
-                          args[i][STATS][TYPE_PROP]
-                        env[rest[i][VALUE]][STATS][RETURNS] =
-                          args[i][STATS][RETURNS]
-                      }
+                      // REFF ASSIGMENT
+                      env[rest[i][VALUE]][STATS][TYPE_PROP] =
+                        args[i][STATS][TYPE_PROP]
+                      env[rest[i][VALUE]][STATS][RETURNS] =
+                        args[i][STATS][RETURNS]
                     }
                   } else if (env[rest[i][0][VALUE]]) {
                     const match = () => {
                       const actual = env[rest[i][0][VALUE]][STATS]
                       const expected = args[i][STATS]
-                      if (args[i][STATS].counter < MAX_ARGUMENT_RETRY) {
-                        args[i][STATS].counter++
-                        stack.unshift(() => match())
-                      }
+                      retryArgs(args[i][STATS], stack, errors, () => match())
                       if (!isUnknownType(expected) && !isUnknownReturn(actual))
                         if (!compareTypeWithReturn(expected, actual))
                           errors.add(
@@ -1092,13 +1090,14 @@ export const typeCheck = (ast, error = true) => {
                                             exp
                                           )}) (check #779)`
                                         )
-                                      else if (
-                                        actual[STATS].retried <
-                                        MAX_RETRY_DEFINITION
-                                      ) {
-                                        actual[STATS].retried += 1
-                                        stack.unshift(() => match1())
-                                      }
+                                      else
+                                        retry(
+                                          actual[STATS],
+                                          stack,
+                                          errors,
+
+                                          () => match1()
+                                        )
                                     }
                                     match1()
                                     for (
@@ -1134,13 +1133,14 @@ export const typeCheck = (ast, error = true) => {
                                               exp
                                             )}) (check #780)`
                                           )
-                                        else if (
-                                          actual[STATS].retried <
-                                          MAX_RETRY_DEFINITION
-                                        ) {
-                                          actual[STATS].retried += 1
-                                          stack.unshift(() => match2())
-                                        }
+                                        else
+                                          retry(
+                                            actual[STATS],
+                                            stack,
+                                            errors,
+
+                                            () => match2()
+                                          )
                                       }
                                       match2()
                                     }
@@ -1155,19 +1155,15 @@ export const typeCheck = (ast, error = true) => {
                             //   break
                           }
                         }
-                      else if (
-                        isUnknownType(expected) &&
-                        args[i][STATS].retried < MAX_RETRY_DEFINITION
-                      ) {
-                        args[i][STATS].retried += 1
-                        stack.unshift(() => match())
-                      }
+                      else if (isUnknownType(expected))
+                        retry(args[i][STATS], stack, errors, () => match())
                     }
                     match()
                   }
                 }
               }
             })
+
             for (let i = 0; i < rest.length; ++i) {
               const r = rest[i]
               if (isLeaf(r) && r[TYPE] !== ATOM)

package/src/types.js

@@ -23,7 +23,7 @@ export const PREDICATE = 4
 export const ANY = 5
 export const ANONYMOUS_FUNCTION_TYPE_PREFIX = 'lambda::annonymous::'
 export const MAX_ARGUMENT_RETRY = 1
-export const MAX_RETRY_DEFINITION = 10
+export const MAX_RETRY_DEFINITION = 100
 export const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
@@ -42,6 +42,14 @@ export const toTypeNames = (type) => {
       break
   }
 }
+export const toTypeNamesAnyToUknown = (type) => {
+  switch (type) {
+    case ANY:
+      return toTypeNames(UNKNOWN)
+    default:
+      return toTypeNames(type)
+  }
+}
 export const SPECIAL_FORM_TYPES = {
   [SCOPE_NAME]: ';',
   // [ORDER]: 0,
@@ -1196,15 +1204,15 @@ export const formatType = (name, env) => {
                   `${
                     getType(x[STATS]) === APPLY
                       ? `${formatType(i, stats[ARGUMENTS])}`
-                      : `${toTypeNames(getType(x[STATS]))}`
+                      : `${toTypeNamesAnyToUknown(getType(x[STATS]))}`
                   }`
               ).join(' ') + ' '
             : ''
           // TODO format returned functions when type support is added
-        }(${KEYWORDS.BLOCK} ${toTypeNames(getReturn(stats))})${
+        }(${KEYWORDS.BLOCK} ${toTypeNamesAnyToUknown(getReturn(stats))})${
           isAnonymous ? '' : ')'
         })`
-      : `(let ${name} ${toTypeNames(getType(stats))})`
+      : `(let ${name} ${toTypeNamesAnyToUknown(getType(stats))})`
     : name
 }