fez-lisp 1.5.160 → 1.5.162

package/package.json

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

package/src/check.js

@@ -309,7 +309,22 @@ export const equalTypes = (a, b) => {
   if (!isSameType) return false
   return true
 }
-
+const isRedifinedInLambda = (env, name, exp) => {
+  if (exp.slice(1, -1).some((x) => x[VALUE] === name)) return true
+  else if (
+    exp
+      .at(-1)
+      .some(
+        (x) =>
+          !isLeaf(x) &&
+          x[0][TYPE] === APPLY &&
+          x[0][VALUE] === KEYWORDS.DEFINE_VARIABLE &&
+          x[1][VALUE] === name
+      )
+  )
+    return true
+  else return false
+}
 export const equalReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const equalsTypeWithReturn = (a, b) =>
@@ -336,7 +351,7 @@ const equalSubTypes = (a, b) => {
     getSubType(a).difference(getSubType(b)).size === 0
   )
 }
-const eualSubReturn = (a, b) => {
+const equalSubReturns = (a, b) => {
   return (
     !hasSubReturn(a) ||
     !hasSubReturn(b) ||
@@ -523,7 +538,6 @@ const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
     const alt = isLeaf(re[1]) ? re[1] : re[1][0]
     const concequent = env[conc[VALUE]]
     const alternative = env[alt[VALUE]]
-
     // TODO make this more simple - it's so many different things just because types are functions or not
     // WHY not consiter making return types for everything
     if (concequent)
@@ -608,7 +622,11 @@ const resolveSetter = (first, rest, env, stack) => {
       : new Set([UNKNOWN])
     switch (right[TYPE]) {
       case ATOM:
-        if (!currentSubType.has(UNKNOWN) && !currentSubType.has(NUMBER))
+        if (
+          !currentSubType.has(ANY) &&
+          !currentSubType.has(UNKNOWN) &&
+          !currentSubType.has(NUMBER)
+        )
           throw new TypeError(
             `Incorrect array type at (${
               first[VALUE]
@@ -642,7 +660,7 @@ const resolveSetter = (first, rest, env, stack) => {
               getSubType(env[right[VALUE]][STATS])
             )
           } else
-            once(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
+            retry(env[right[VALUE]][STATS], [first[VALUE], rest], stack, () =>
               resolveSetter(first, rest, env, stack)
             )
         }
@@ -773,9 +791,31 @@ const resolveReturnType = ({
   check
 }) => {
   if (returns[TYPE] === ATOM) setPropToAtom(env[name][STATS], prop)
-  else {
+  else if (returns[TYPE] === WORD) {
+    if (env[returns[VALUE]]) {
+      if (!isUnknownType(env[returns[VALUE]][STATS]))
+        setPropToType(env[name][STATS], prop, env[returns[VALUE]][STATS])
+      else
+        once(env[name][STATS], exp, stack, () => {
+          setPropToTypeRef(env[name][STATS], prop, env[returns[VALUE]][STATS])
+          if (isUnknownProp(env[name][STATS], prop)) {
+            // TODO: DRY
+            const index = env[name][STATS][ARGUMENTS]
+              ? env[name][STATS][ARGUMENTS].findIndex(
+                  (x) => x[STATS][SIGNATURE] === returns[VALUE]
+                )
+              : -1
+            if (index >= 0) {
+              setReturnToGeneric(env[name][STATS], index)
+              return true
+            } else if (!env[returns[VALUE]]) return false
+          }
+        })
+    }
+  } else {
     switch (returns[VALUE]) {
       case KEYWORDS.CREATE_ARRAY:
+        setPropToCollection(env[name][STATS], prop)
         setPropToSubReturn(env[name][STATS], prop, initArrayType({ rem, env }))
         break
       case KEYWORDS.IF:
@@ -800,11 +840,13 @@ const resolveReturnType = ({
               })
             })
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
+          // TODO: DRY
           const index = env[name][STATS][ARGUMENTS]
             ? env[name][STATS][ARGUMENTS].findIndex(
                 (x) => x[STATS][SIGNATURE] === returns[VALUE]
               )
             : -1
+
           if (index >= 0) {
             setReturnToGeneric(env[name][STATS], index)
             return true
@@ -892,7 +934,12 @@ const resolveReturnType = ({
                       env[returns[VALUE]][STATS]
                     )
                 })
-              else setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
+              else {
+                // if (SPECIAL_FORMS_SET.has(returns[VALUE]))
+                //   setReturn(env[name][STATS], env[returns[VALUE]][STATS])
+                // else
+                setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
+              }
             }
           }
         }
@@ -1011,7 +1058,7 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                           getReturn(actual[STATS])
                         )}) (${stringifyArgs(exp)}) (check #779)`
                       )
-                    else if (!eualSubReturn(expected[STATS], actual[STATS]))
+                    else if (!equalSubReturns(expected[STATS], actual[STATS]))
                       throw new TypeError(
                         `Incorrect return type for (${
                           expected[STATS][SIGNATURE]
@@ -1053,7 +1100,7 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                           getType(actual[STATS])
                         )}) (${stringifyArgs(exp)}) (check #780)`
                       )
-                    else if (!eualSubReturn(expected[STATS], actual[STATS]))
+                    else if (!equalSubReturns(expected[STATS], actual[STATS]))
                       throw new TypeError(
                         `Incorrect return type for (${
                           expected[STATS][SIGNATURE]
@@ -1132,8 +1179,37 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                   exp
                 )})`
               )
-
             if (name in env) {
+              // const [head, ...tail] = isLeaf(rest.at(-1))
+              //   ? [rest.at(-1)]
+              //   : rest.at(-1)
+              // const ref = env[name]
+              // if (ref) {
+              //   if (getType(ref[STATS]) === APPLY && head[TYPE] !== APPLY)
+              //     throw new TypeError(
+              //       `Miss-matching type for (${name}) predifined expected type is (${toTypeNames(
+              //         APPLY
+              //       )}) but got (${stringifyArgs(exp)})`
+              //     )
+              //   const returns = deepLambdaReturn(
+              //     hasBlock(tail) ? tail.at(-1) : tail,
+              //     (result) => result[VALUE] !== KEYWORDS.IF
+              //   )
+              //   const [rhead] = isLeaf(returns) ? [returns] : returns
+              //   const rightRef = env[rhead[VALUE]]
+              //   if (rightRef)
+              //     if (
+              //       !equalReturns(ref[STATS], rightRef[STATS]) ||
+              //       !equalSubReturns(ref[STATS], rightRef[STATS])
+              //     )
+              //       throw new TypeError(
+              //         `Miss-matching return type for (${name}) predifined expected return is (${formatSubType(
+              //           getReturns(ref[STATS])
+              //         )}) but got (${formatSubType(
+              //           getReturns(rightRef[STATS])
+              //         )}) (${stringifyArgs(exp)})`
+              //       )
+              // }
               Types.set(withScope(name, env), () => formatType(name, env))
               break
             }
@@ -1158,29 +1234,11 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                   [RETURNS]: [UNKNOWN]
                 }
               }
-              if (
-                !checkReturnType({
-                  stack,
-                  exp,
-                  env,
-                  name,
-                  check
-                }) ||
-                isUnknownReturn(env[name][STATS])
-              ) {
-                retry(env[name][STATS], [first, env], stack, () => {
-                  checkReturnType({
-                    stack,
-                    exp,
-                    env,
-                    name,
-                    check
-                  })
-                  // TODO: remove this as maybe it is not needed
+              check(rightHand, env, exp)
+              if (isUnknownReturn(env[name][STATS]))
+                retry(env[name][STATS], exp, stack, () =>
                   check(rightHand, env, exp)
-                })
-                check(rightHand, env, exp)
-              } else check(rightHand, env, exp)
+                )
             } else {
               checkPredicateName(exp, rest)
               const isLeafNode = isLeaf(rightHand)
@@ -1227,105 +1285,146 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                   : env[right[VALUE]][STATS][RETURNS][0]
                 if (type !== UNKNOWN)
                   setTypeToReturn(env[name][STATS], env[right[VALUE]][STATS])
-                const body = rightHand
-                const rem = hasBlock(body) ? body.at(-1) : body
-                const returns = isLeaf(rem) ? rem : rem[0]
-                resolveReturnType({
-                  stack,
-                  returns,
-                  rem,
-                  prop: TYPE_PROP,
-                  exp,
-                  env,
-                  name,
-                  check
-                })
+                const resolve = () => {
+                  const body = rightHand
+                  const rem = hasBlock(body) ? body.at(-1) : body
+                  const returns = isLeaf(rem) ? rem : rem[0]
+                  resolveReturnType({
+                    stack,
+                    returns,
+                    rem,
+                    prop: TYPE_PROP,
+                    exp,
+                    env,
+                    name,
+                    check
+                  })
+                }
+                resolve()
+                if (isUnknownType(env[name][STATS]))
+                  once(env[name][STATS], exp, stack, () => resolve())
               }
               check(rightHand, env, scope)
             }
             Types.set(withScope(name, env), () => formatType(name, env))
             break
           case KEYWORDS.ANONYMOUS_FUNCTION:
-            validateLambda(exp)
-            const params = exp.slice(1, -1)
-            const copy = Object.create(env)
-            if (Array.isArray(scope[1]) && scope[1][TYPE] === WORD)
-              copy[SCOPE_NAME] = scope[1][VALUE]
-            else copy[SCOPE_NAME] = ++scopeIndex
-            for (let i = 0; i < params.length; ++i) {
-              const param = params[i]
-              // TODO move this somewhere else
-              if (!isLeaf(param))
-                throw new TypeError(
-                  `Invalid body for (${
-                    first[VALUE]
-                  }) if it takes more than one expression it must be wrapped in a (${
-                    KEYWORDS.BLOCK
-                  }) (${stringifyArgs(exp)}) (check #666)`
-                )
-              copy[param[VALUE]] = {
-                [STATS]: {
-                  [IS_ARGUMENT]: true,
-                  [SIGNATURE]: param[VALUE],
-                  [TYPE_PROP]: [UNKNOWN],
-                  [RETURNS]: [UNKNOWN],
-                  [ARGUMENTS]: [],
-                  argIndex: i,
-                  retried: 0,
-                  counter: 0
+            {
+              validateLambda(exp)
+              const params = exp.slice(1, -1)
+              const copy = Object.create(env)
+              if (Array.isArray(scope[1]) && scope[1][TYPE] === WORD)
+                copy[SCOPE_NAME] = scope[1][VALUE]
+              else copy[SCOPE_NAME] = ++scopeIndex
+              const ref = env[copy[SCOPE_NAME]]
+              for (let i = 0; i < params.length; ++i) {
+                const param = params[i]
+                // TODO move this somewhere else
+                if (!isLeaf(param))
+                  throw new TypeError(
+                    `Invalid body for (${
+                      first[VALUE]
+                    }) if it takes more than one expression it must be wrapped in a (${
+                      KEYWORDS.BLOCK
+                    }) (${stringifyArgs(exp)}) (check #666)`
+                  )
+                copy[param[VALUE]] = {
+                  [STATS]: {
+                    [IS_ARGUMENT]: true,
+                    [SIGNATURE]: param[VALUE],
+                    [TYPE_PROP]: [UNKNOWN],
+                    [RETURNS]: [UNKNOWN],
+                    [ARGUMENTS]: [],
+                    argIndex: i,
+                    retried: 0,
+                    counter: 0
+                  }
                 }
+                if (!ref) continue
+                ref[STATS][ARGUMENTS][i] = copy[param[VALUE]]
+                // TODO overwrite return type check here
               }
-              const ref = env[copy[SCOPE_NAME]]
-              if (!ref) continue
-              ref[STATS][ARGUMENTS][i] = copy[param[VALUE]]
-              // TODO overwrite return type check here
-            }
-            const returns = deepLambdaReturn(
-              hasBlock(exp) ? exp.at(-1) : exp,
-              (result) => result[VALUE] !== KEYWORDS.IF
-            )
-            const ref = env[copy[SCOPE_NAME]]
-            if (ref)
-              if (isLeaf(returns))
-                // TODO figure out what we do here
-                // this here is a variable WORD
-                // so return type of that function is that varible type
-                stagger(
-                  stack,
-                  'append',
-                  [returns, copy],
-                  () =>
-                    copy[returns[VALUE]] &&
-                    setReturnToType(ref[STATS], copy[returns[VALUE]][STATS])
-                )
-              else {
-                stagger(stack, 'append', [returns, copy], () => {
-                  const ret = returns[0]
-                  switch (ret[VALUE]) {
-                    case KEYWORDS.IF:
-                      resolveCondition({
-                        rem: returns,
-                        name: ref[STATS][SIGNATURE],
-                        env: copy,
-                        exp,
-                        stack,
-                        prop: RETURNS,
-                        check
-                      })
+              const returns = deepLambdaReturn(
+                hasBlock(exp) ? exp.at(-1) : exp,
+                (result) => result[VALUE] !== KEYWORDS.IF
+              )
+              if (ref)
+                if (isLeaf(returns)) {
+                  // TODO figure out what we do here
+                  // this here is a variable WORD
+                  // so return type of that function is that varible type
+                  switch (returns[TYPE]) {
+                    case ATOM:
+                      setReturnToAtom(ref[STATS])
                       break
-                    default:
-                      if (copy[ret[VALUE]]) {
-                        setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
-                      } else
-                        stagger(stack, 'append', [ret, copy], () => {
-                          if (copy[ret[VALUE]])
-                            setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
-                        })
+                    case WORD:
+                      stagger(stack, 'append', [returns, copy], () => {
+                        copy[returns[VALUE]] &&
+                          checkReturnType({
+                            stack,
+                            exp: [
+                              [APPLY, KEYWORDS.DEFINE_VARIABLE],
+                              [WORD, ref[STATS][SIGNATURE]],
+                              exp
+                            ],
+                            env: copy,
+                            name: ref[STATS][SIGNATURE],
+                            check
+                          })
+                        // setReturnToType(
+                        //   ref[STATS],
+                        //   copy[returns[VALUE]][STATS]
+                        // )
+                      })
                       break
                   }
-                })
-              }
-            check(rest.at(-1), copy, copy)
+                } else {
+                  stagger(stack, 'append', [returns, copy], () => {
+                    retry(ref[STATS], exp, stack, () => {
+                      checkReturnType({
+                        stack,
+                        exp: [
+                          [APPLY, KEYWORDS.DEFINE_VARIABLE],
+                          [WORD, ref[STATS][SIGNATURE]],
+                          exp
+                        ],
+                        env: copy,
+                        name: ref[STATS][SIGNATURE],
+                        check
+                      })
+                    })
+                    // const ret = returns[0]
+                    // switch (ret[VALUE]) {
+                    //   case KEYWORDS.IF:
+                    //     resolveCondition({
+                    //       rem: returns,
+                    //       name: ref[STATS][SIGNATURE],
+                    //       env: copy,
+                    //       exp,
+                    //       stack,
+                    //       prop: RETURNS,
+                    //       check
+                    //     })
+                    //     break
+                    //   default:
+                    //     if (copy[ret[VALUE]]) {
+                    //       if (isUnknownReturn(copy[ret[VALUE]][STATS])) {
+                    //         once(ref[STATS], [returns, copy], stack, () => {
+                    //           setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
+                    //         })
+                    //       } else setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
+                    //     } else
+                    //       stagger(stack, 'append', [ret, copy], () => {
+                    //         if (copy[ret[VALUE]])
+                    //           setReturnRef(ref[STATS], copy[ret[VALUE]][STATS])
+                    //       })
+                    //     break
+                    // }
+                  })
+                }
+              check(rest.at(-1), copy, copy)
+            }
+
             break
           case STATIC_TYPES.ABSTRACTION:
           case STATIC_TYPES.COLLECTION:

package/src/keywords.js

@@ -113,6 +113,10 @@ export const MUTATORS_SET = new Set([
 ])
 export const GETTERS_SET = new Set([
   KEYWORDS.GET_ARRAY,
+  'array:first',
+  'array:second',
+  'array:third',
+  'array:last',
   'matrix:get',
   'matrix:set-and-get!',
   'array:set-and-get!',

package/src/types.js

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