fez-lisp 1.5.126 → 1.5.129

package/package.json

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

package/src/check.js

@@ -52,6 +52,7 @@ import {
   getSuffix,
   hasApplyLambdaBlock,
   hasBlock,
+  log,
   logExp,
   stringifyArgs
 } from './utils.js'
@@ -113,10 +114,16 @@ export const isUnknownNotAnyType = (stats) =>
 export const isUnknownNotAnyReturn = (stats) =>
   stats && !isAnyReturn(stats) && isUnknownReturn(stats)
 export const castType = (stats, type) => {
-  return (stats[TYPE_PROP][0] = type[RETURNS][0])
+  return (
+    (stats[TYPE_PROP][0] = type[RETURNS][0]),
+    (stats[TYPE_PROP][1] = type[RETURNS][1])
+  )
 }
 export const castReturn = (stats, type) => {
-  return (stats[RETURNS][0] = type[RETURNS][0])
+  return (
+    (stats[RETURNS][0] = type[RETURNS][0]),
+    (stats[RETURNS][1] = type[RETURNS][1])
+  )
 }
 export const isTypeAbstraction = (stats) => stats[TYPE_PROP] === APPLY
 export const setPropToAtom = (stats, prop) => {
@@ -129,7 +136,7 @@ export const setPropToPredicate = (stats, prop) => {
   return (stats[prop][1] = BOOLEAN_SUBTYPE())
 }
 export const setReturnToPredicate = (stats) => {
-  return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
+  return (stats[RETURNS][0] = BOOLEAN_SUBTYPE())
 }
 export const setTypeToPredicate = (stats) => {
   return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
@@ -195,6 +202,9 @@ export const setTypeRef = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   (stats[TYPE_PROP] = value[TYPE_PROP])
 export const setReturnRef = (stats, value) => {
+  if (SPECIAL_FORMS_SET.has(value[SIGNATURE])) {
+    return setReturn(stats, value)
+  }
   return isUnknownReturn(stats) && (stats[RETURNS] = value[RETURNS])
 }
 export const setReturnToTypeRef = (stats, value) => {
@@ -237,7 +247,7 @@ export const setPropToSubType = (stats, prop, value) =>
   hasSubType(value) && (stats[prop][1] = value[TYPE_PROP][1])
 export const setPropToSubReturn = (stats, prop, value) =>
   // makes no senseto protect this for now
-  hasSubType(value) && (stats[prop][1] = value[RETURNS][1])
+  hasSubReturn(value) && (stats[prop][1] = value[RETURNS][1])
 export const setTypeToReturn = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   !isUnknownReturn(value) &&
@@ -264,12 +274,25 @@ export const getSubType = (stats) => stats && stats[TYPE_PROP][1]
 export const hasSubType = (stats) => stats && stats[TYPE_PROP][1] instanceof Set
 export const getSubReturn = (stats) => stats && stats[RETURNS][1]
 export const hasSubReturn = (stats) => stats && stats[RETURNS][1] instanceof Set
+export const isUknownSubReturn = (stats) =>
+  !hasSubReturn(stats) ||
+  (stats[RETURNS][1].size === 1 && stats[RETURNS][1].has(UNKNOWN))
+export const isUknownSubType = (stats) =>
+  hasSubType(stats) &&
+  stats[TYPE_PROP][1].size === 1 &&
+  stats[TYPE_PROP][1].has(UNKNOWN)
 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) =>
-  isAnyType(a) || isAnyType(b) || a[TYPE_PROP][0] === b[TYPE_PROP][0]
+export const compareTypes = (a, b) => {
+  const isAnyAny = isAnyType(a) || isAnyType(b)
+  if (isAnyAny) return true
+  const isSameType = a[TYPE_PROP][0] === b[TYPE_PROP][0]
+  if (!isSameType) return false
+  return true
+}
+
 export const compareReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const compareTypeWithReturn = (a, b) =>
@@ -285,6 +308,7 @@ 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) &&
@@ -294,15 +318,25 @@ const notABooleanType = (a, b) => {
     (!hasSubType(b) || getSubType(a).difference(getSubType(b)).size !== 0)
   )
 }
+// const notABooleanReturn = (a, b) => {
+//   return (
+//     hasSubType(a) &&
+//     getSubType(a).has(PREDICATE) &&
+//     !isUnknownReturn(b) &&
+//     !isAnyReturn(b) &&
+//     (
+//       !isAtomReturn(b) ||
+//       !hasSubReturn(b) ||
+//       getSubType(a).difference(getSubReturn(b)).size !== 0)
+//   )
+// }
 const notABooleanReturn = (a, b) => {
   return (
     hasSubType(a) &&
     getSubType(a).has(PREDICATE) &&
     !isUnknownReturn(b) &&
     !isAnyReturn(b) &&
-    (!isAtomReturn(b) ||
-      !hasSubReturn(b) ||
-      getSubType(a).difference(getSubReturn(b)).size !== 0)
+    (!hasSubReturn(b) || getSubType(a).difference(getSubReturn(b)).size !== 0)
   )
 }
 const isAtomABoolean = (atom) => atom === TRUE || atom === FALSE
@@ -516,39 +550,44 @@ const resolveSetter = (first, rest, env) => {
   ) {
     const name = rest[0][VALUE]
     const current = env[name]
-    if (!hasSubType(current[STATS])) {
-      const right = isLeaf(rest.at(-1)) ? rest.at(-1) : rest.at(-1)[0]
-      switch (right[TYPE]) {
-        case ATOM:
-          current[STATS][TYPE_PROP][1] = new Set([NUMBER])
-          break
-        case WORD:
-          if (env[right[VALUE]]) {
-            if (hasSubType(env[right[VALUE]][STATS]))
-              current[STATS][TYPE_PROP][1] = new Set(
-                getSubType(env[right[VALUE]][STATS])
-              )
-            else
-              current[STATS][TYPE_PROP][1] = new Set([
-                getType(env[right[VALUE]][STATS])
-              ])
-          }
-          break
-        case APPLY:
-          if (env[right[VALUE]]) {
-            if (hasSubReturn(env[right[VALUE]][STATS]))
-              current[STATS][TYPE_PROP][1] = new Set([
-                ...getSubReturn(env[right[VALUE]][STATS])
-              ])
-            else
-              current[STATS][TYPE_PROP][1] = new Set([
-                env[right[VALUE]][STATS][RETURNS][0]
-              ])
+    const right = isLeaf(rest.at(-1)) ? rest.at(-1) : rest.at(-1)[0]
+    switch (right[TYPE]) {
+      case ATOM:
+        current[STATS][TYPE_PROP][1] = new Set([NUMBER])
+        break
+      case WORD:
+        if (env[right[VALUE]]) {
+          if (hasSubType(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set(
+              getSubType(env[right[VALUE]][STATS])
+            )
+          else
+            current[STATS][TYPE_PROP][1] = new Set([
+              getType(env[right[VALUE]][STATS])
+            ])
+        }
+        break
+      case APPLY:
+        if (env[right[VALUE]]) {
+          if (right[VALUE] === KEYWORDS.CREATE_ARRAY) {
+            current[STATS][TYPE_PROP][1] = (initArrayType({
+              rem: rest.at(-1),
+              env
+            }) ?? { [RETURNS]: [COLLECTION, new Set([])] })[RETURNS][1]
+            break
           }
-          break
-      }
-      setTypeToCollection(current[STATS])
+          if (hasSubReturn(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set([
+              ...getSubReturn(env[right[VALUE]][STATS])
+            ])
+          else if (!isUnknownReturn(env[right[VALUE]][STATS]))
+            current[STATS][TYPE_PROP][1] = new Set([
+              getReturn(env[right[VALUE]][STATS])
+            ])
+        }
+        break
     }
+    setTypeToCollection(current[STATS])
   }
 }
 const resolveGetter = ({ rem, prop, name, env }) => {
@@ -572,7 +611,10 @@ const resolveGetter = ({ rem, prop, name, env }) => {
       {
         if (hasSubType(env[array[VALUE]][STATS])) {
           const rightSub = getSubType(env[array[VALUE]][STATS])
-          const isAtom = rightSub.has(NUMBER) || rightSub.has(PREDICATE)
+          const isAtom =
+            rightSub.has(ATOM) ||
+            rightSub.has(NUMBER) ||
+            rightSub.has(PREDICATE)
           const isCollection = rightSub.has(COLLECTION)
           if (isAtom && !isCollection) {
             setPropToAtom(env[name][STATS], prop)
@@ -586,12 +628,45 @@ const resolveGetter = ({ rem, prop, name, env }) => {
   }
   return true
 }
+const initArrayType = ({ rem, env }) => {
+  const ret = rem
+    .slice(1)
+    .map((x) =>
+      isLeaf(x)
+        ? x[TYPE] === WORD
+          ? env[x[VALUE]]
+            ? getTypes(env[x[VALUE]][STATS])
+            : [UNKNOWN]
+          : [x[TYPE]]
+        : env[x[0][VALUE]]
+        ? getReturns(env[x[0][VALUE]][STATS])
+        : [UNKNOWN]
+    )
+  const known = ret.find((x) => x[0] !== ANY && x[0] !== UNKNOWN)
+  if (
+    known &&
+    ret.length &&
+    !ret.some((x) => known[0] !== x[0] || known.length !== x.length)
+  ) {
+    const [main, sub] = ret[0]
+    return {
+      [TYPE_PROP]: [APPLY],
+      [RETURNS]: [COLLECTION, new Set(sub ? [...sub] : [main])]
+    }
+  }
+}
 const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
   if (returns[TYPE] === ATOM) {
     // ATOM ASSIGMENT
     setPropToAtom(env[name][STATS], prop)
   } else {
     switch (returns[VALUE]) {
+      case KEYWORDS.CREATE_ARRAY:
+        {
+          const r = initArrayType({ rem, env })
+          if (r) setPropToSubReturn(env[name][STATS], prop, r)
+        }
+        break
       case KEYWORDS.IF:
         resolveCondition({ rem, name, env, exp, prop })
         break
@@ -881,6 +956,7 @@ export const typeCheck = (ast) => {
           case STATIC_TYPES.ATOM:
           case STATIC_TYPES.PREDICATE:
           case STATIC_TYPES.ANY:
+          case STATIC_TYPES.NUMBER:
             {
               const ret = isLeaf(rest[0]) ? rest[0] : rest[0][0]
               const ref = env[ret[VALUE]]
@@ -979,10 +1055,12 @@ export const typeCheck = (ast) => {
                   // const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
                   const MAIN_TYPE = getType(args[i][STATS])
                   if (MAIN_TYPE === ANY) continue
+                  // TODO - try to merge special and non special
                   if (first[TYPE] === APPLY && isSpecial) {
                     if (!isResLeaf) {
                       const name = rest[i][0][VALUE]
                       if (!env[name]) continue
+                      // there is a problem here with cond pr when passed as an argument
                       if (name === KEYWORDS.IF) {
                         const concequent = [...rest]
                         const alternative = [...rest]
@@ -998,6 +1076,7 @@ export const typeCheck = (ast) => {
                           check(exp, env, scope)
                         )
                       } else if (
+                        !isUnknownType(args[i][STATS]) &&
                         !isUnknownReturn(env[name][STATS]) &&
                         !compareTypeWithReturn(args[i][STATS], env[name][STATS])
                       )
@@ -1011,6 +1090,7 @@ export const typeCheck = (ast) => {
                           )}) (${stringifyArgs(exp)}) (check #1)`
                         )
                       else if (
+                        !isUnknownReturn(args[i][STATS]) &&
                         !isUnknownReturn(env[name][STATS]) &&
                         notABooleanReturn(args[i][STATS], env[name][STATS])
                       )
@@ -1046,6 +1126,7 @@ export const typeCheck = (ast) => {
                             const name = rest[i][VALUE]
                             if (!env[name]) continue
                             if (
+                              !isUnknownType(args[i][STATS]) &&
                               !isUnknownType(env[name][STATS]) &&
                               !compareTypes(args[i][STATS], env[name][STATS])
                             )
@@ -1059,6 +1140,7 @@ export const typeCheck = (ast) => {
                                 )}) (${stringifyArgs(exp)}) (check #3)`
                               )
                             else if (
+                              !isUnknownType(args[i][STATS]) &&
                               !isUnknownType(env[name][STATS]) &&
                               notABooleanType(args[i][STATS], env[name][STATS])
                             )
@@ -1071,11 +1153,28 @@ export const typeCheck = (ast) => {
                                   getTypes(env[name][STATS])
                                 )}) (${stringifyArgs(exp)}) (check #202)`
                               )
-                            else setType(env[name][STATS], args[i][STATS])
+                            else {
+                              // TODO the special form will set type first but it
+                              // might be known already
+                              // example
+                              // (let xs [])
+                              // (let x (array:set-and-get! xs 0 100))
+                              // (length x)
+                              //
+                              // if (isUnknownType(env[name][STATS])) {
+                              //   retry(env[name][STATS], stack, () =>
+                              //     check(exp, env, scope)
+                              //   )
+                              // } else
+                              setType(env[name][STATS], args[i][STATS])
+                            }
                           }
                           break
                         case ATOM: {
-                          if (rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0])
+                          if (
+                            !isUnknownType(args[i][STATS]) &&
+                            rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0]
+                          )
                             throw new TypeError(
                               `Incorrect type of argument (${i}) for special form (${
                                 first[VALUE]
@@ -1298,7 +1397,11 @@ export const typeCheck = (ast) => {
                     }
                   } else if (env[rest[i][0][VALUE]]) {
                     const match = () => {
-                      const actual = env[rest[i][0][VALUE]][STATS]
+                      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))
@@ -1314,13 +1417,13 @@ export const typeCheck = (ast) => {
                           )
                         else if (notABooleanReturn(expected, actual)) {
                           throw new TypeError(
-                            `Incorrect type of argument (${i}) for special form (${
+                            `Incorrect type of argument (${i}) for (${
                               first[VALUE]
                             }). Expected (${formatSubType(
                               getTypes(expected)
                             )}) but got (${formatSubType(
                               getReturns(actual)
-                            )}) (${stringifyArgs(exp)}) (check #204)`
+                            )}) (${stringifyArgs(exp)}) (check #206)`
                           )
                         } else {
                           switch (getType(expected)) {

package/src/compiler.js

@@ -275,6 +275,7 @@ const comp = (tree, Drill) => {
       case STATIC_TYPES.ATOM:
       case STATIC_TYPES.PREDICATE:
       case STATIC_TYPES.ANY:
+      case STATIC_TYPES.NUMBER:
       case DEBUG.ASSERT:
       case DEBUG.LOG:
       case DEBUG.STRING:

package/src/interpreter.js

@@ -837,6 +837,7 @@ export const keywords = {
   [STATIC_TYPES.ATOM]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.COLLECTION]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.PREDICATE]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.NUMBER]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.UNKNOWN]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.ANY]: (args, env) => evaluate(args[0], env)
 }

package/src/keywords.js

@@ -9,6 +9,7 @@ export const PLACEHOLDER = '.'
 export const MUTATION_SUFFIX = '!'
 export const PREDICATE_SUFFIX = '?'
 export const STATIC_TYPES = {
+  NUMBER: 'Number',
   ABSTRACTION: 'Abstraction',
   UNKNOWN: 'Unknown',
   ATOM: 'Atom',

package/src/types.js

@@ -30,7 +30,6 @@ export const NIL = 'nil'
 export const TRUE_WORD = 'true'
 export const FALSE_WORD = 'false'
 export const BOOLEAN_SUBTYPE = () => new Set([PREDICATE])
-export const ANY_SUBTYPE = () => new Set([ANY])
 export const COLLECTION_SUBTYPE = () => new Set([COLLECTION])
 export const NUMBER_SUBTYPE = () => new Set([NUMBER])
 
@@ -134,6 +133,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
+  [STATIC_TYPES.NUMBER]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.NUMBER,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
+    }
+  },
   [STATIC_TYPES.COLLECTION]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -765,8 +785,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: 0,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [COLLECTION, ANY_SUBTYPE()],
-            [RETURNS]: [COLLECTION, ANY_SUBTYPE()],
+            [TYPE_PROP]: [COLLECTION],
+            [RETURNS]: [COLLECTION],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -795,7 +815,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [COLLECTION, ANY_SUBTYPE()]
+      [RETURNS]: [COLLECTION]
     }
   },
   [KEYWORDS.POP_ARRAY]: {

package/src/utils.js

@@ -24,6 +24,10 @@ export const logExp = function (exp, ...args) {
   console.log(wrapInBracesString(exp), ...args)
   return exp
 }
+export const log = (x) => {
+  console.log(x)
+  return x
+}
 export const formatCallstack = (callstack) =>
   callstack
     .reverse()
@@ -332,6 +336,7 @@ export const addTypeIdentities = (ast) => {
     identity(STATIC_TYPES.ATOM),
     identity(STATIC_TYPES.COLLECTION),
     identity(STATIC_TYPES.PREDICATE),
+    identity(STATIC_TYPES.NUMBER),
     identity(STATIC_TYPES.ANY),
     identity(STATIC_TYPES.UNKNOWN)
   )