fez-lisp 1.5.130 → 1.5.132

package/package.json

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

package/src/check.js

@@ -116,13 +116,13 @@ export const isUnknownNotAnyReturn = (stats) =>
 export const castType = (stats, type) => {
   return (
     (stats[TYPE_PROP][0] = type[RETURNS][0]),
-    (stats[TYPE_PROP][1] = type[RETURNS][1])
+    type[RETURNS][1] && (stats[TYPE_PROP][1] = type[RETURNS][1])
   )
 }
 export const castReturn = (stats, type) => {
   return (
     (stats[RETURNS][0] = type[RETURNS][0]),
-    (stats[RETURNS][1] = type[RETURNS][1])
+    stats[RETURNS][1] && (stats[RETURNS][1] = type[RETURNS][1])
   )
 }
 export const isTypeAbstraction = (stats) => stats[TYPE_PROP] === APPLY
@@ -285,7 +285,7 @@ export const isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
   isAnyType(stats) || stats[RETURNS][0] === ATOM
-export const compareTypes = (a, b) => {
+export const equalsTypes = (a, b) => {
   const isAnyAny = isAnyType(a) || isAnyType(b)
   if (isAnyAny) return true
   const isSameType = a[TYPE_PROP][0] === b[TYPE_PROP][0]
@@ -293,9 +293,9 @@ export const compareTypes = (a, b) => {
   return true
 }
 
-export const compareReturns = (a, b) =>
+export const equalsReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
-export const compareTypeWithReturn = (a, b) =>
+export const equalsTypeWithReturn = (a, b) =>
   isAnyType(a) || isAnyReturn(b) || a[TYPE_PROP][0] === b[RETURNS][0]
 const IsPredicate = (leaf) =>
   (leaf[TYPE] === ATOM && (leaf[VALUE] === TRUE || leaf[VALUE] === FALSE)) ||
@@ -319,7 +319,7 @@ const notABooleanType = (a, b) => {
       (hasSubType(b) && getSubType(a).difference(getSubType(b)).size !== 0))
   )
 }
-const notABooleanReturn = (a, b) => {
+const notABooleanTypeWithReturn = (a, b) => {
   return (
     hasSubType(a) &&
     getSubType(a).has(PREDICATE) &&
@@ -328,6 +328,15 @@ const notABooleanReturn = (a, b) => {
     (!hasSubReturn(b) || getSubType(a).difference(getSubReturn(b)).size !== 0)
   )
 }
+const notABooleanReturn = (a, b) => {
+  return (
+    hasSubReturn(a) &&
+    getSubReturn(a).has(PREDICATE) &&
+    !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) {
@@ -406,19 +415,20 @@ const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
   return `${chain.length === 1 ? '; ' : ''}${chain.join(' ')} ${name}`
 }
-const retry = (stats, stack, cb) => {
+const retry = (stats, ctx, stack, cb) => {
   if (
     (isUnknownNotAnyType(stats) || isUnknownNotAnyReturn(stats)) &&
     stats.retried < MAX_RETRY_DEFINITION
   ) {
     stats.retried += 1
-    stack.prepend(() => cb())
+    stagger(stack, 'prepend', ctx, cb)
   }
 }
-const retryArgs = (stats, stack, cb) => {
+
+const retryArgs = (stats, ctx, stack, cb) => {
   if (stats.counter < MAX_ARGUMENT_RETRY) {
     stats.counter++
-    stack.prepend(cb)
+    stagger(stack, 'prepend', ctx, cb)
   }
 }
 const IfApplyBranch = ({ leaf, branch, re, prop, ref, env }) => {
@@ -521,7 +531,7 @@ const resolveCondition = ({ rem, name, env, exp, prop }) => {
     default:
       if (env[ret[VALUE]]) setPropRef(ref[STATS], prop, env[ret[VALUE]][STATS])
       else
-        stack.append(() => {
+        stagger(stack, 'append', exp, () => {
           if (env[ret[VALUE]])
             setPropRef(ref[STATS], prop, env[ret[VALUE]][STATS])
         })
@@ -665,7 +675,7 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
             GETTERS_SET.has(returns[VALUE]) &&
             !resolveGetter({ rem, prop, name, env })
           )
-            return retry(env[name][STATS], stack, () => {
+            return retry(env[name][STATS], [returns, env], stack, () => {
               resolveRetunType({
                 returns,
                 rem,
@@ -686,7 +696,7 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
               // rest.at(-1)[0][TYPE] === APPLY
               // Here is upon application to store the result in the variable
               if (isUnknownType(env[name][STATS]))
-                stack.prepend(() => {
+                stagger(stack, 'prepend', exp, () => {
                   setTypeToReturnRef(
                     env[name][STATS],
                     env[returns[VALUE]][STATS]
@@ -716,11 +726,188 @@ const checkReturnType = ({ exp, stack, name, env }) => {
     stack
   })
 }
+const stagger = (stack, method, data, fn) => {
+  // console.log(data[0], data[1])
+  stack[method]({ data, fn })
+}
 export const typeCheck = (ast) => {
-  let scopeIndex = 0
-  const root = structuredClone(SPECIAL_FORM_TYPES)
   const Types = new Map()
   const stack = new Brr()
+  let scopeIndex = 0
+  // TODO also handle casting
+  const match = ({ rest, args, i, env, scope, exp }) => {
+    const first = exp[0]
+    const actual =
+      rest[i][0][VALUE] === KEYWORDS.CREATE_ARRAY
+        ? initArrayType({ rem: rest[i], env }) ?? env[rest[i][0][VALUE]][STATS]
+        : env[rest[i][0][VALUE]][STATS]
+    const expected = args[i][STATS]
+    retryArgs(args[i][STATS], exp, stack, () =>
+      match({ rest, args, i, env, scope, exp })
+    )
+    if (!isUnknownType(expected) && !isUnknownReturn(actual))
+      if (!equalsTypeWithReturn(expected, actual))
+        throw new TypeError(
+          `Incorrect type of argument (${i}) for (${
+            first[VALUE]
+          }). Expected (${toTypeNames(
+            getType(expected)
+          )}) but got (${toTypeNames(getReturn(actual))}) (${stringifyArgs(
+            exp
+          )}) (check #16)`
+        )
+      else if (notABooleanTypeWithReturn(expected, actual)) {
+        throw new TypeError(
+          `Incorrect type of argument (${i}) for (${
+            first[VALUE]
+          }). Expected (${formatSubType(
+            getTypes(expected)
+          )}) but got (${formatSubType(getReturns(actual))}) (${stringifyArgs(
+            exp
+          )}) (check #206)`
+        )
+      } else {
+        switch (getType(expected)) {
+          // almost exclusively for anonymous lambdas
+          case APPLY:
+            {
+              const argsN = rest[i].length - 2
+              if (
+                env[rest[i][0][VALUE]][STATS][SIGNATURE] ===
+                KEYWORDS.ANONYMOUS_FUNCTION
+              ) {
+                if (argsN !== args[i][STATS][ARG_COUNT])
+                  throw new TypeError(
+                    `Incorrect number of arguments for (${
+                      args[i][STATS][SIGNATURE]
+                    }) the (${KEYWORDS.ANONYMOUS_FUNCTION}) argument of (${
+                      first[VALUE]
+                    }) at position (${i}). Expected (= ${
+                      args[i][STATS][ARG_COUNT]
+                    }) but got ${argsN} (${stringifyArgs(exp)}) (check #777)`
+                  )
+                else {
+                  // ANONYMOUS LAMBDAS TYPE CHECKING
+                  const local = Object.create(env)
+                  const lambdaName = `${ANONYMOUS_FUNCTION_TYPE_PREFIX}${i}::${++scopeIndex}`
+                  check(
+                    [
+                      [APPLY, KEYWORDS.DEFINE_VARIABLE],
+                      [WORD, lambdaName],
+                      rest[i]
+                    ],
+                    local,
+                    scope
+                  )
+                  // TODO delete this maybe
+                  // #C2
+                  // It will not be possilbe to know return type
+                  const match1 = () => {
+                    const actual = local[lambdaName]
+                    const expected = args[i]
+                    if (
+                      !isUnknownReturn(expected[STATS]) &&
+                      !isUnknownReturn(actual[STATS]) &&
+                      !equalsReturns(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 #779)`
+                      )
+                    else if (notABooleanReturn(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 #783)`
+                      )
+                    else
+                      retry(
+                        actual[STATS],
+                        [[WORD, lambdaName], local],
+                        stack,
+                        match1
+                      )
+                  }
+                  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]) &&
+                        !equalsTypes(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)`
+                        )
+                      else if (
+                        notABooleanReturn(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)`
+                        )
+                      else
+                        retry(
+                          actual[STATS],
+                          [[WORD, lambdaName], local],
+                          stack,
+                          match2
+                        )
+                    }
+                    match2()
+                  }
+                }
+              } else {
+                // TODO fix curry: lambdas enter here as undefined
+              }
+            }
+            break
+          // case ATOM:
+          // case COLLECTION:
+          //   break
+        }
+      }
+    else if (isUnknownType(expected))
+      retry(args[i][STATS], [first, env], stack, () =>
+        match({ rest, args, i, env, scope, exp })
+      )
+  }
   const check = (exp, env, scope) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first === undefined)
@@ -732,7 +919,7 @@ export const typeCheck = (ast) => {
     switch (first[TYPE]) {
       case WORD:
         if (!isSpecial)
-          stack.append(() => {
+          stagger(stack, 'append', [first, env], () => {
             // Figure out how to determine if varible is define after it's used
             if (env[first[VALUE]] === undefined) {
               throw new TypeError(
@@ -787,7 +974,7 @@ export const typeCheck = (ast) => {
                 }) ||
                 isUnknownReturn(env[name][STATS])
               ) {
-                retry(env[name][STATS], stack, () => {
+                retry(env[name][STATS], [first, env], stack, () => {
                   checkReturnType({
                     stack,
                     exp,
@@ -906,13 +1093,16 @@ export const typeCheck = (ast) => {
                 // TODO figure out what we do here
                 // this here is a variable WORD
                 // so return type of that function is that varible type
-                stack.append(
+                stagger(
+                  stack,
+                  'append',
+                  [returns, copy],
                   () =>
                     copy[returns[VALUE]] &&
                     setReturnToType(ref[STATS], copy[returns[VALUE]][STATS])
                 )
               else {
-                stack.append(() => {
+                stagger(stack, 'append', [returns, copy], () => {
                   const ret = returns[0]
                   switch (ret[VALUE]) {
                     case KEYWORDS.IF:
@@ -929,7 +1119,7 @@ export const typeCheck = (ast) => {
                       if (copy[ret[VALUE]])
                         setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                       else
-                        stack.append(() => {
+                        stagger(stack, 'append', [ret, copy], () => {
                           if (copy[ret[VALUE]])
                             setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
                         })
@@ -950,7 +1140,7 @@ export const typeCheck = (ast) => {
               const ret = isLeaf(rest[0]) ? rest[0] : rest[0][0]
               const ref = env[ret[VALUE]]
               if (!ref) break
-              const caster = root[first[VALUE]]
+              const caster = SPECIAL_FORM_TYPES[first[VALUE]]
               if (ret[TYPE] === APPLY && isUnknownReturn(ref[STATS]))
                 castReturn(ref[STATS], caster[STATS])
               else if (isUnknownType(ref[STATS]))
@@ -963,9 +1153,8 @@ export const typeCheck = (ast) => {
             // So they MUST happen before Judgement
             resolveSetter(first, rest, env)
             // end of Var  ---------------
-
             // Judgement
-            stack.append(() => {
+            stagger(stack, 'append', [first, env], () => {
               if (!isSpecial && env[first[VALUE]] === undefined)
                 throw new TypeError(
                   `Trying to call undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) ${first[VALUE]} (check #9)`
@@ -1082,7 +1271,7 @@ export const typeCheck = (ast) => {
                             }
                             if (
                               isKnown &&
-                              !compareTypes(args[i][STATS], env[name][STATS])
+                              !equalsTypes(args[i][STATS], env[name][STATS])
                             )
                               throw new TypeError(
                                 `Incorrect type of argument (${i}) for (${
@@ -1114,12 +1303,16 @@ export const typeCheck = (ast) => {
                               // (let xs [])
                               // (let x (array:set-and-get! xs 0 100))
                               // (length x)
-                              //
-                              // if (isUnknownType(env[name][STATS])) {
-                              //   retry(env[name][STATS], stack, () =>
+
+                              // if (
+                              //   isUnknownType(env[name][STATS]) &&
+                              //   !env[name][STATS].tried
+                              // ) {
+                              //   once(env[name][STATS], stack, () =>
                               //     check(exp, env, scope)
                               //   )
-                              // } else
+                              // }
+
                               if (isSpecial)
                                 setType(env[name][STATS], args[i][STATS])
                             }
@@ -1207,7 +1400,7 @@ export const typeCheck = (ast) => {
                             if (
                               !isUnknownReturn(expected[STATS]) &&
                               !isUnknownReturn(actual[STATS]) &&
-                              !compareReturns(expected[STATS], actual[STATS])
+                              !equalsReturns(expected[STATS], actual[STATS])
                             ) {
                               throw new TypeError(
                                 `Incorrect return type for (${
@@ -1222,7 +1415,8 @@ export const typeCheck = (ast) => {
                                   getReturn(actual[STATS])
                                 )}) (${stringifyArgs(exp)}) (check #782)`
                               )
-                            } else retry(actual[STATS], stack, () => match1())
+                            } else
+                              retry(actual[STATS], [first, env], stack, match1)
                           }
                           match1()
                           for (
@@ -1236,7 +1430,7 @@ export const typeCheck = (ast) => {
                               if (
                                 !isUnknownType(actual[STATS]) &&
                                 !isUnknownType(expected[STATS]) &&
-                                !compareTypes(actual[STATS], expected[STATS])
+                                !equalsTypes(actual[STATS], expected[STATS])
                               )
                                 throw new TypeError(
                                   `Incorrect type for (${
@@ -1251,7 +1445,13 @@ export const typeCheck = (ast) => {
                                     getType(actual[STATS])
                                   )}) (${stringifyArgs(exp)}) (check #781)`
                                 )
-                              else retry(actual[STATS], stack, () => match2())
+                              else
+                                retry(
+                                  actual[STATS],
+                                  [first, env],
+                                  stack,
+                                  match2
+                                )
                             }
                             match2()
                           }
@@ -1260,7 +1460,7 @@ export const typeCheck = (ast) => {
                       if (!isSpecial) {
                         const name = rest[i][VALUE]
                         if (isUnknownType(args[i][STATS])) {
-                          retry(args[i][STATS], stack, () =>
+                          retry(args[i][STATS], [first, env], stack, () =>
                             check(exp, env, scope)
                           )
                         }
@@ -1284,235 +1484,45 @@ export const typeCheck = (ast) => {
                     } else {
                       const name = rest[i][0][VALUE]
                       if (!env[name]) continue
-                      if (isSpecial) {
-                        // there is a problem here with cond pr when passed as an argument
-                        if (name === KEYWORDS.IF) {
-                          const concequent = [...rest]
-                          const alternative = [...rest]
-                          concequent[i] = rest[i][1]
-                          alternative[i] = rest[i][2]
-                          check([first, ...concequent], env, scope)
-                          check([first, ...alternative], env, scope)
-                        } else if (
-                          isUnknownReturn(env[name][STATS]) &&
-                          !env[name][STATS][IS_ARGUMENT]
-                        ) {
-                          return retry(env[name][STATS], stack, () =>
-                            check(exp, env, scope)
-                          )
-                        } else if (
-                          !isUnknownType(args[i][STATS]) &&
-                          !isUnknownReturn(env[name][STATS]) &&
-                          !compareTypeWithReturn(
-                            args[i][STATS],
-                            env[name][STATS]
-                          )
-                        )
-                          throw new TypeError(
-                            `Incorrect type of argument (${i}) for (${
-                              first[VALUE]
-                            }). Expected (${toTypeNames(
-                              getType(args[i][STATS])
-                            )}) but got (${toTypeNames(
-                              getReturn(env[name][STATS])
-                            )}) (${stringifyArgs(exp)}) (check #1)`
-                          )
-                        else if (
-                          !isUnknownReturn(args[i][STATS]) &&
-                          !isUnknownReturn(env[name][STATS]) &&
-                          notABooleanReturn(args[i][STATS], env[name][STATS])
+                      if (
+                        isUnknownReturn(env[name][STATS]) &&
+                        !env[name][STATS][IS_ARGUMENT]
+                      )
+                        return retry(
+                          env[name][STATS],
+                          [first, env],
+                          stack,
+                          () => check(exp, env, scope)
                         )
-                          throw new TypeError(
-                            `Incorrect type of argument (${i}) for (${
-                              first[VALUE]
-                            }). Expected (${formatSubType(
-                              getTypes(args[i][STATS])
-                            )}) but got (${formatSubType(
-                              getReturns(env[name][STATS])
-                            )}) (${stringifyArgs(exp)}) (check #201)`
-                          )
-                        else {
-                          if (env[name] && getType(env[name][STATS]) === APPLY)
-                            switch (first[VALUE]) {
-                              case KEYWORDS.IF:
-                                break
-                              default:
-                                // TODO fix this assigment
-                                // It turns out it's not possible to determine return type of function here
-                                // what if it's a global function used elsewhere where the return type mwould be different
-                                // THIS willgive lambda return types but refactor is needed still
-                                if (!SPECIAL_FORMS_SET.has(name))
-                                  setReturnRef(env[name][STATS], args[i][STATS])
-                                break
-                            }
-                          // TODO also handle casting
-                        }
-                      } else {
-                        const match = () => {
-                          const actual =
-                            rest[i][0][VALUE] === KEYWORDS.CREATE_ARRAY
-                              ? initArrayType({ rem: rest[i], env }) ??
-                                env[rest[i][0][VALUE]][STATS]
-                              : env[rest[i][0][VALUE]][STATS]
-                          const expected = args[i][STATS]
-                          retryArgs(args[i][STATS], stack, () => match())
-                          if (
-                            !isUnknownType(expected) &&
-                            !isUnknownReturn(actual)
-                          )
-                            if (!compareTypeWithReturn(expected, actual))
-                              throw new TypeError(
-                                `Incorrect type of argument (${i}) for (${
-                                  first[VALUE]
-                                }). Expected (${toTypeNames(
-                                  getType(expected)
-                                )}) but got (${toTypeNames(
-                                  getReturn(actual)
-                                )}) (${stringifyArgs(exp)}) (check #16)`
-                              )
-                            else if (notABooleanReturn(expected, actual)) {
-                              throw new TypeError(
-                                `Incorrect type of argument (${i}) for (${
-                                  first[VALUE]
-                                }). Expected (${formatSubType(
-                                  getTypes(expected)
-                                )}) but got (${formatSubType(
-                                  getReturns(actual)
-                                )}) (${stringifyArgs(exp)}) (check #206)`
-                              )
-                            } else {
-                              switch (getType(expected)) {
-                                // almost exclusively for anonymous lambdas
-                                case APPLY:
-                                  {
-                                    const argsN = rest[i].length - 2
-                                    if (
-                                      env[rest[i][0][VALUE]][STATS][
-                                        SIGNATURE
-                                      ] === KEYWORDS.ANONYMOUS_FUNCTION
-                                    ) {
-                                      if (argsN !== args[i][STATS][ARG_COUNT])
-                                        throw new TypeError(
-                                          `Incorrect number of arguments for (${
-                                            args[i][STATS][SIGNATURE]
-                                          }) the (${
-                                            KEYWORDS.ANONYMOUS_FUNCTION
-                                          }) argument of (${
-                                            first[VALUE]
-                                          }) at position (${i}). Expected (= ${
-                                            args[i][STATS][ARG_COUNT]
-                                          }) but got ${argsN} (${stringifyArgs(
-                                            exp
-                                          )}) (check #777)`
-                                        )
-                                      else {
-                                        // ANONYMOUS LAMBDAS TYPE CHECKING
-                                        const local = Object.create(env)
-                                        const lambdaName = `${ANONYMOUS_FUNCTION_TYPE_PREFIX}${i}::${++scopeIndex}`
-                                        check(
-                                          [
-                                            [APPLY, KEYWORDS.DEFINE_VARIABLE],
-                                            [WORD, lambdaName],
-                                            rest[i]
-                                          ],
-                                          local,
-                                          scope
-                                        )
-                                        // TODO delete this maybe
-                                        // #C2
-                                        // It will not be possilbe to know return type
-                                        const match1 = () => {
-                                          const actual = local[lambdaName]
-                                          const expected = args[i]
-                                          if (
-                                            !isUnknownReturn(expected[STATS]) &&
-                                            !isUnknownReturn(actual[STATS]) &&
-                                            !compareReturns(
-                                              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 #779)`
-                                            )
-                                          else
-                                            retry(actual[STATS], stack, () =>
-                                              match1()
-                                            )
-                                        }
-                                        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]) &&
-                                              !compareTypes(
-                                                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)`
-                                              )
-                                            else
-                                              retry(actual[STATS], stack, () =>
-                                                match2()
-                                              )
-                                          }
-                                          match2()
-                                        }
-                                      }
-                                    } else {
-                                      // TODO fix curry: lambdas enter here as undefined
-                                    }
-                                  }
-                                  break
-                                // case ATOM:
-                                // case COLLECTION:
-                                //   break
-                              }
-                            }
-                          else if (isUnknownType(expected))
-                            retry(args[i][STATS], stack, () => match())
-                        }
-                        match()
+
+                      if (isSpecial && name === KEYWORDS.IF) {
+                        const concequent = [...rest]
+                        const alternative = [...rest]
+                        concequent[i] = rest[i][1]
+                        alternative[i] = rest[i][2]
+                        check([first, ...concequent], env, scope)
+                        check([first, ...alternative], env, scope)
                       }
+
+                      if (
+                        env[name] &&
+                        getType(env[name][STATS]) === APPLY &&
+                        !SPECIAL_FORMS_SET.has(name)
+                      )
+                        switch (first[VALUE]) {
+                          case KEYWORDS.IF:
+                            break
+                          default:
+                            // TODO fix this assigment
+                            // It turns out it's not possible to determine return type of function here
+                            // what if it's a global function used elsewhere where the return type mwould be different
+                            // THIS willgive lambda return types but refactor is needed still
+                            // if (!SPECIAL_FORMS_SET.has(name))
+                            setReturnRef(env[name][STATS], args[i][STATS])
+                            break
+                        }
+
+                      match({ rest, args, i, env, scope, exp })
                     }
                   }
                   // REFACTORING
@@ -1538,8 +1548,8 @@ export const typeCheck = (ast) => {
     }
   }
   const copy = JSON.parse(JSON.stringify(ast))
-  check(copy, root, copy)
-  while (stack.length) stack.cut()()
+  check(copy, SPECIAL_FORM_TYPES, copy)
+  while (stack.length) stack.cut().fn()
   return [ast, Types]
 }
 export const type = (ast) => typeCheck(ast)[0]

package/src/types.js

@@ -419,7 +419,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.MULTIPLICATION]: {
@@ -452,7 +452,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.SUBTRACTION]: {
@@ -485,7 +485,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.DIVISION]: {
@@ -518,7 +518,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.REMAINDER_OF_DIVISION]: {
@@ -550,7 +550,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_AND]: {
@@ -583,7 +583,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_NOT]: {
@@ -605,7 +605,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_OR]: {
@@ -638,7 +638,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_XOR]: {
@@ -671,7 +671,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_LEFT_SHIFT]: {
@@ -704,7 +704,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.BITWISE_RIGHT_SHIFT]: {
@@ -737,7 +737,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.GET_ARRAY]: {
@@ -859,7 +859,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
     }
   },
   [KEYWORDS.IF]: {

package/src/utils.js

@@ -462,6 +462,27 @@ export class Brr {
     for (let i = half; i < initial.length; ++i) this._addToRight(initial[i])
     return this
   }
+  static from(iterable) {
+    const out = new Brr()
+    const half = (iterable.length / 2) | 0.5
+    for (let i = half - 1; i >= 0; --i) out._addToLeft(iterable[i])
+    for (let i = half; i < iterable.length; ++i) out._addToRight(iterable[i])
+    return out
+  }
+  /**
+   * Returns the elements of an array that meet the condition specified in a callback function.
+   * @param predicate — A function that accepts up to three arguments.
+   * The filter method calls the predicate function one time for each element in the array.
+   */
+  filter(callback = _Identity) {
+    const out = []
+    for (let i = 0, len = this.length; i < len; ++i) {
+      const current = this.get(i)
+      const predicat = callback(current, i, this)
+      if (predicat) out.push(current)
+    }
+    return Brr.from(out)
+  }
   // reverse() {
   //   const left = this._left
   //   const right = this._right