fez-lisp 1.6.52 → 1.6.54

package/package.json

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

package/src/check.js

@@ -45,7 +45,8 @@ import {
   IS_ARGUMENT,
   NUMBER,
   NUMBER_SUBTYPE,
-  UNKNOWN_SUBTYPE
+  UNKNOWN_SUBTYPE,
+  SubType
 } from './types.js'
 import {
   Brr,
@@ -56,32 +57,7 @@ import {
   logExp,
   stringifyArgs
 } from './utils.js'
-Set.prototype.union = function (B) {
-  const A = this
-  const out = new Set()
-  A.forEach((element) => out.add(element))
-  B.forEach((element) => out.add(element))
-  return out
-}
-Set.prototype.xor = function (B) {
-  const A = this
-  const out = new Set()
-  B.forEach((element) => !A.has(element) && out.add(element))
-  A.forEach((element) => !B.has(element) && out.add(element))
-  return out
-}
-Set.prototype.intersection = function (B) {
-  const A = this
-  const out = new Set()
-  B.forEach((element) => A.has(element) && out.add(element))
-  return out
-}
-Set.prototype.difference = function (B) {
-  const A = this
-  const out = new Set()
-  A.forEach((element) => !B.has(element) && out.add(element))
-  return out
-}
+
 export const identity = (name) => [
   [0, 'let'],
   [1, name],
@@ -289,30 +265,36 @@ export const isUnknownType = (stats) => stats && stats[TYPE_PROP][0] === UNKNOWN
 export const isUnknownProp = (stats, prop) => {
   return stats && stats[prop][0] === UNKNOWN
 }
-
+export const isSubType = (subtype) => subtype instanceof SubType
+export const isSubTypeUknown = (subtype) =>
+  subtype.size === 1 && subtype.has(UNKNOWN)
+export const matchSub = (a, b) =>
+  a.has(UNKNOWN) ||
+  b.has(UNKNOWN) ||
+  a.has(ANY) ||
+  b.has(ANY) ||
+  a.isMatching(b)
 export const isUnknownReturn = (stats) => stats[RETURNS][0] === UNKNOWN
 export const getType = (stats) => stats && stats[TYPE_PROP][0]
 export const getTypes = (stats) => stats && stats[TYPE_PROP]
 export const getReturn = (stats) => stats && stats[RETURNS][0]
 export const getReturns = (stats) => stats && stats[RETURNS]
 export const getSubType = (stats) => stats && stats[TYPE_PROP][1]
-export const hasSubType = (stats) => stats && stats[TYPE_PROP][1] instanceof Set
+export const hasSubType = (stats) => stats && isSubType(stats[TYPE_PROP][1])
 export const getSubReturn = (stats) => stats && stats[RETURNS][1]
-export const hasSubReturn = (stats) => stats && stats[RETURNS][1] instanceof Set
+export const hasSubReturn = (stats) => stats && isSubType(stats[RETURNS][1])
 export const isUnknownSubReturn = (stats) =>
   !hasSubReturn(stats) ||
   (stats &&
     stats[RETURNS] &&
     stats[RETURNS][1] &&
-    stats[RETURNS][1].size === 1 &&
-    stats[RETURNS][1].has(UNKNOWN))
+    isSubTypeUknown(stats[RETURNS][1]))
 export const isUnknownSubType = (stats) =>
   hasSubType(stats) &&
   stats &&
   stats[TYPE_PROP] &&
   stats[TYPE_PROP][1] &&
-  stats[TYPE_PROP][1].size === 1 &&
-  stats[TYPE_PROP][1].has(UNKNOWN)
+  isSubTypeUknown(stats[TYPE_PROP][1])
 export const isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
@@ -357,35 +339,21 @@ const IsPredicate = (leaf) =>
 
 const equalSubTypes = (a, b) => {
   return (
-    !hasSubType(a) ||
-    !hasSubType(b) ||
-    getSubType(a).has(UNKNOWN) ||
-    getSubType(b).has(UNKNOWN) ||
-    getSubType(a).has(ANY) ||
-    getSubType(b).has(ANY) ||
-    getSubType(a).difference(getSubType(b)).size === 0
+    !hasSubType(a) || !hasSubType(b) || matchSub(getSubType(a), getSubType(b))
   )
 }
 const equalSubReturns = (a, b) => {
   return (
     !hasSubReturn(a) ||
     !hasSubReturn(b) ||
-    getSubReturn(a).has(UNKNOWN) ||
-    getSubReturn(b).has(UNKNOWN) ||
-    getSubReturn(a).has(ANY) ||
-    getSubReturn(b).has(ANY) ||
-    getSubReturn(a).difference(getSubReturn(b)).size === 0
+    matchSub(getSubReturn(a), getSubReturn(b))
   )
 }
 const equalSubTypesWithSubReturn = (a, b) => {
   return (
     !hasSubType(a) ||
     !hasSubReturn(b) ||
-    getSubType(a).has(UNKNOWN) ||
-    getSubReturn(b).has(UNKNOWN) ||
-    getSubType(a).has(ANY) ||
-    getSubReturn(b).has(ANY) ||
-    getSubType(a).difference(getSubReturn(b)).size === 0
+    matchSub(getSubType(a), getSubReturn(b))
   )
 }
 const isAtomABoolean = (atom) => atom === TRUE || atom === FALSE
@@ -542,7 +510,16 @@ const IfApplyBranch = ({
       }
       break
     default:
-      return setPropToReturnRef(ref[STATS], prop, branch[STATS])
+      if (
+        getType(ref[STATS]) === UNKNOWN &&
+        getReturn(branch[STATS]) === UNKNOWN
+      ) {
+        retry(ref[STATS], exp, stack, () =>
+          setPropToReturn(ref[STATS], prop, branch[STATS])
+        )
+        return true
+      }
+      return setPropToReturn(ref[STATS], prop, branch[STATS])
   }
 }
 const ifExpression = ({ re, env, ref, prop, stack, exp, check }) => {
@@ -554,6 +531,7 @@ 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 consider making return types for everything
     if (concequent)
@@ -621,6 +599,56 @@ const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
       break
   }
 }
+const resolveGetter = ({ rem, prop, name, env }) => {
+  const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
+  if (!env[array[VALUE]] || !env[name]) return true
+
+  switch (array[TYPE]) {
+    case APPLY:
+      if (hasSubType(env[array[VALUE]][STATS])) {
+        const rightSub = getSubReturn(env[array[VALUE]][STATS])
+        const isAtom = rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
+        const isCollection = rightSub.has(COLLECTION)
+        if (isAtom && !isCollection) {
+          setPropToAtom(env[name][STATS], prop)
+          setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
+        } else if (!isAtom && isCollection) {
+          setPropToReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
+          // TODO: handle this nested array overwrite better
+          if (getSubReturn(env[array[VALUE]][STATS]).has(COLLECTION))
+            setPropToSubReturn(env[name][STATS], prop, {
+              [RETURNS]: [COLLECTION, UNKNOWN_SUBTYPE()]
+            })
+        } else return false
+      } else return false
+      break
+    case WORD:
+      {
+        if (hasSubType(env[array[VALUE]][STATS])) {
+          const rightSub = getSubType(env[array[VALUE]][STATS])
+          const isAtom =
+            rightSub.has(ATOM) || rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
+          const isCollection = rightSub.has(COLLECTION)
+          if (isAtom && !isCollection) {
+            setPropToAtom(env[name][STATS], prop)
+            setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
+          } else if (!isAtom && isCollection) {
+            setPropToType(env[name][STATS], prop, {
+              [TYPE_PROP]: [
+                env[array[VALUE]][STATS][TYPE_PROP][1].types[0],
+                new SubType(
+                  env[array[VALUE]][STATS][TYPE_PROP][1].types.slice(1)
+                )
+              ]
+            })
+          } else return false
+        } else return false
+      }
+      break
+  }
+  return true
+}
+
 const resolveSetter = (first, rest, env, stack) => {
   if (
     getSuffix(first[VALUE]) === MUTATION_SUFFIX &&
@@ -635,7 +663,7 @@ const resolveSetter = (first, rest, env, stack) => {
     const right = isLeaf(rest.at(-1)) ? rest.at(-1) : rest.at(-1)[0]
     const currentSubType = hasSubType(current[STATS])
       ? getSubType(current[STATS])
-      : new Set([UNKNOWN])
+      : new SubType([UNKNOWN])
     switch (right[TYPE]) {
       case ATOM:
         if (
@@ -659,7 +687,7 @@ const resolveSetter = (first, rest, env, stack) => {
         if (env[right[VALUE]]) {
           if (hasSubType(env[right[VALUE]][STATS])) {
             if (currentSubType.has(UNKNOWN))
-              current[STATS][TYPE_PROP][1] = new Set([
+              current[STATS][TYPE_PROP][1] = new SubType([
                 ...getSubType(env[right[VALUE]][STATS])
               ])
             else if (!equalSubTypes(current[STATS], env[right[VALUE]][STATS]))
@@ -672,7 +700,7 @@ const resolveSetter = (first, rest, env, stack) => {
                   getTypes(env[right[VALUE]][STATS])
                 )}) (${stringifyArgs([first, rest])}) (check #198)`
               )
-            current[STATS][TYPE_PROP][1] = new Set(
+            current[STATS][TYPE_PROP][1] = new SubType(
               getSubType(env[right[VALUE]][STATS])
             )
           } else
@@ -683,7 +711,7 @@ const resolveSetter = (first, rest, env, stack) => {
         break
       case APPLY:
         if (env[right[VALUE]]) {
-          if (right[VALUE] === KEYWORDS.CREATE_ARRAY) {
+          if (right[VALUE] === 'array:get') {
             current[STATS][TYPE_PROP][1] = initArrayType({
               rem: rest.at(-1),
               env
@@ -692,7 +720,7 @@ const resolveSetter = (first, rest, env, stack) => {
           }
           if (hasSubReturn(env[right[VALUE]][STATS])) {
             if (currentSubType.has(UNKNOWN))
-              current[STATS][TYPE_PROP][1] = new Set([
+              current[STATS][TYPE_PROP][1] = new SubType([
                 ...getSubReturn(env[right[VALUE]][STATS])
               ])
             else if (
@@ -710,7 +738,7 @@ const resolveSetter = (first, rest, env, stack) => {
                   getReturns(env[right[VALUE]][STATS])
                 )}) (${stringifyArgs([first, rest])}) (check #198)`
               )
-            current[STATS][TYPE_PROP][1] = new Set([
+            current[STATS][TYPE_PROP][1] = new SubType([
               ...getSubReturn(env[right[VALUE]][STATS])
             ])
           }
@@ -729,81 +757,52 @@ const resolveSetter = (first, rest, env, stack) => {
     //   )
   }
 }
-const resolveGetter = ({ rem, prop, name, env }) => {
-  const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
-  if (!env[array[VALUE]] || !env[name]) return true
-  switch (array[TYPE]) {
-    case APPLY:
-      if (hasSubType(env[array[VALUE]][STATS])) {
-        const rightSub = getSubReturn(env[array[VALUE]][STATS])
-        const isAtom = rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
-        const isCollection = rightSub.has(COLLECTION)
-        if (isAtom && !isCollection) {
-          setPropToAtom(env[name][STATS], prop)
-          setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
-        } else if (!isAtom && isCollection) {
-          setPropToReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
-          // TODO: handle this nested array overwrite better
-          if (getSubReturn(env[array[VALUE]][STATS]).has(COLLECTION))
-            setPropToSubReturn(env[name][STATS], prop, {
-              [RETURNS]: [COLLECTION, UNKNOWN_SUBTYPE()]
-            })
-        } else return false
-      } else return false
-      break
-    case WORD:
-      {
-        if (hasSubType(env[array[VALUE]][STATS])) {
-          const rightSub = getSubType(env[array[VALUE]][STATS])
-          const isAtom =
-            rightSub.has(ATOM) || rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
-          const isCollection = rightSub.has(COLLECTION)
-          if (isAtom && !isCollection) {
-            setPropToAtom(env[name][STATS], prop)
-            setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
-          } else if (!isAtom && isCollection) {
-            setPropToType(env[name][STATS], prop, env[array[VALUE]][STATS])
-            // TODO: handle this nested array overwrite better
-            if (getSubType(env[array[VALUE]][STATS]).has(COLLECTION))
-              setPropToSubType(env[name][STATS], prop, {
-                [TYPE_PROP]: [COLLECTION, UNKNOWN_SUBTYPE()]
-              })
-          } else return false
-        } else return false
-      }
-      break
-  }
-  return true
+const initArrayTypeRec = ({ rem, env }) => {
+  return rem.slice(1).map((x) =>
+    isLeaf(x)
+      ? x[TYPE] === WORD
+        ? env[x[VALUE]]
+          ? // env[x[VALUE]][STATS][TYPE_PROP][0] === COLLECTION
+            //   ? initArrayTypeRec({ rem: x, env })
+            //   :
+            getTypes(env[x[VALUE]][STATS])
+          : [UNKNOWN]
+        : [
+            x[TYPE],
+            x[TYPE] === ATOM ? NUMBER_SUBTYPE() : new SubType([UNKNOWN])
+          ]
+      : env[x[0][VALUE]]
+      ? x.length > 1 && env[x[0][VALUE]][STATS][RETURNS][0] === COLLECTION
+        ? initArrayTypeRec({ rem: x, env })
+        : getReturns(env[x[0][VALUE]][STATS])
+      : [UNKNOWN]
+  )
 }
 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], x[TYPE] === ATOM ? NUMBER_SUBTYPE() : new Set([UNKNOWN])]
-        : env[x[0][VALUE]]
-        ? getReturns(env[x[0][VALUE]][STATS])
-        : [UNKNOWN]
-    )
+  const ret = initArrayTypeRec({ rem, env })
   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)
-  ) {
+  // console.log(known[0], ret[0])
+  if (known && ret.length) {
+    if (Array.isArray(ret[0][0])) {
+      let head = ret[0][0]
+      ret[0].length = 0
+      const subT = new SubType([COLLECTION])
+      ret[0].push(COLLECTION, subT)
+      while (head && !isSubType(head[1])) {
+        subT.add(COLLECTION)
+        head = head[0]
+      }
+      if (head) subT.add(head[1].types[0])
+    }
     const [main, sub] = ret[0]
     return {
       [TYPE_PROP]: [APPLY],
-      [RETURNS]: [COLLECTION, new Set(sub ? [...sub] : [main])]
+      [RETURNS]: [COLLECTION, new SubType(isSubType(sub) ? [...sub] : [main])]
     }
   } else
     return {
       [TYPE_PROP]: [APPLY],
-      [RETURNS]: [COLLECTION, new Set([UNKNOWN])]
+      [RETURNS]: [COLLECTION, new SubType([UNKNOWN])]
     }
 }
 const resolveReturnType = ({
@@ -849,6 +848,8 @@ const resolveReturnType = ({
         break
       default:
         {
+          if (returns[VALUE] === KEYWORDS.GET_ARRAY)
+            resolveGetter({ rem, prop, name, env })
           // if (
           //   !GETTERS_SET.has(name) &&
           //   GETTERS_SET.has(returns[VALUE]) &&
@@ -1386,8 +1387,11 @@ export const typeCheck = (
                   : env[right[VALUE]] == undefined
                   ? UNKNOWN
                   : env[right[VALUE]][STATS][RETURNS][0]
-                if (type !== UNKNOWN)
+
+                if (type !== UNKNOWN && type !== ANY) {
                   setTypeToReturn(env[name][STATS], env[right[VALUE]][STATS])
+                }
+
                 const resolve = () => {
                   const body = rightHand
                   const rem = hasBlock(body) ? body.at(-1) : body
@@ -1404,6 +1408,7 @@ export const typeCheck = (
                   })
                 }
                 resolve()
+
                 if (isUnknownType(env[name][STATS]))
                   once(env[name][STATS], exp, stack, () => resolve())
               }
@@ -1530,6 +1535,14 @@ export const typeCheck = (
             // Setters are just like DEFINE_VARIABLE as they are essentially the Var case for Collections
             // So they MUST happen before Judgement
             resolveSetter(first, rest, env, stack)
+            if (first[VALUE] === 'array:get-infer' && first[TYPE] === APPLY) {
+              resolveGetter({
+                rem: rest[0],
+                prop: TYPE_PROP,
+                name: rest[0],
+                env
+              })
+            }
             // end of Var  ---------------
             // Judgement
             const judge = () => {

package/src/types.js

@@ -1,6 +1,6 @@
 import stdT from '../lib/baked/std-T.js'
 import std from '../lib/baked/std.js'
-import { getReturn, getReturns, getType, getTypes } from './check.js'
+import { getReturn, getReturns, getType, getTypes, isSubType } from './check.js'
 import {
   APPLY,
   ATOM,
@@ -36,11 +36,45 @@ export const IS_ARGUMENT = 'is_arg'
 export const NIL = 'nil'
 export const TRUE_WORD = 'true'
 export const FALSE_WORD = 'false'
-export const BOOLEAN_SUBTYPE = () => new Set([BOOLEAN])
-export const COLLECTION_SUBTYPE = () => new Set([COLLECTION])
-export const NUMBER_SUBTYPE = () => new Set([NUMBER])
-export const ABSTRACTION_SUBTYPE = () => new Set([APPLY])
-export const UNKNOWN_SUBTYPE = () => new Set([UNKNOWN])
+export class SubType {
+  constructor(args) {
+    this.types = []
+    this.types.push(...args)
+  }
+  add(type) {
+    this.types.push(type)
+    return this
+  }
+  has(type) {
+    return this.types[0] === type
+  }
+  isMatching(b) {
+    for (let i = 0; i < this.types.length; ++i) {
+      if (
+        this.types[i] == undefined ||
+        b.types[i] == undefined ||
+        this.types[i] === UNKNOWN ||
+        b.types[i] === UNKNOWN ||
+        this.types[i] === ANY ||
+        b.types[i] === ANY
+      )
+        return true
+      if (this.types[i] !== b.types[i]) return false
+    }
+    return true
+  }
+  get size() {
+    return this.types.length
+  }
+  *[Symbol.iterator]() {
+    for (let i = 0, len = this.size; i < len; ++i) yield this.types[i]
+  }
+}
+export const BOOLEAN_SUBTYPE = () => new SubType([BOOLEAN])
+export const COLLECTION_SUBTYPE = () => new SubType([COLLECTION])
+export const NUMBER_SUBTYPE = () => new SubType([NUMBER])
+export const ABSTRACTION_SUBTYPE = () => new SubType([APPLY])
+export const UNKNOWN_SUBTYPE = () => new SubType([UNKNOWN])
 
 const SPECIAL_BOOLEAN = BOOLEAN_SUBTYPE()
 const SPECIAL_COLLECTION = COLLECTION_SUBTYPE()
@@ -82,18 +116,22 @@ export const toTypeCodes = (type) => {
       return [UNKNOWN]
     case 'Unknown[]':
     case 'Unknowns':
-    case 'Collection':
-      return [COLLECTION, new Set([ANY])]
+      // case 'Collection':
+      return [COLLECTION, new SubType([ANY])]
     case 'Numbers':
     case 'Number[]':
       return [COLLECTION, NUMBER_SUBTYPE()]
     case 'Booleans':
     case 'Boolean[]':
       return [COLLECTION, BOOLEAN_SUBTYPE()]
-    case 'Collections':
-    case 'Collection[]':
+    // case 'Collections':
+    // case 'Collection[]':
     case 'Unknown[][]':
       return [COLLECTION, COLLECTION_SUBTYPE()]
+    case 'Boolean[][]':
+      return [COLLECTION, new SubType([COLLECTION, BOOLEAN])]
+    case 'Number[][]':
+      return [COLLECTION, new SubType([COLLECTION, NUMBER])]
     case 'Any':
       return [ANY]
     default:
@@ -954,7 +992,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      // [GENERIC, new Set([PLACEHOLDER]), 0]
+      // [GENERIC, new SubType([PLACEHOLDER]), 0]
       [RETURNS]: [COLLECTION]
     }
   },
@@ -1307,20 +1345,18 @@ export const formatSubType = (T) => {
   switch (T[0]) {
     case COLLECTION:
       return `${
-        T[1] instanceof Set
-          ? [...T[1]]
-              .map((x) =>
-                x === COLLECTION
-                  ? formatSubType([x])
-                  : toTypeNamesAnyToUknown(x)
-              )
-              .join(' ') || toTypeNames(UNKNOWN)
+        isSubType(T[1])
+          ? T[1].has(COLLECTION)
+            ? `${toTypeNamesAnyToUknown(T[1].types.at(-1))}${'[]'.repeat(
+                T[1].types.length - 1
+              )}`
+            : toTypeNamesAnyToUknown(T[1].types[0]) || toTypeNames(UNKNOWN)
           : toTypeNames(UNKNOWN)
       }[]`
     case ATOM:
       return `${
-        T[1] instanceof Set
-          ? [...T[1]].map((x) => toTypeNamesAnyToUknown(x)).join(' ')
+        isSubType(T[1])
+          ? toTypeNamesAnyToUknown(T[1].types[0])
           : toTypeNamesAnyToUknown(NUMBER)
       }`
     default:
@@ -1378,7 +1414,7 @@ export const formatAstSubType = (T) => {
   switch (T[0]) {
     case COLLECTION:
       return `${
-        T[1] instanceof Set
+        isSubType(T[1])
           ? [...T[1]]
               .map((x) =>
                 x === COLLECTION
@@ -1390,7 +1426,7 @@ export const formatAstSubType = (T) => {
       }[]`
     case ATOM:
       return `${
-        T[1] instanceof Set
+        isSubType(T[1])
           ? [...T[1]].map((x) => toTypeNamesAnyToUknown(x)).join(' ')
           : toTypeNamesAnyToUknown(NUMBER)
       }`