fez-lisp 1.5.109 → 1.5.111

package/package.json

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

package/src/check.js

@@ -38,7 +38,12 @@ import {
   formatType,
   ANONYMOUS_FUNCTION_TYPE_PREFIX,
   validateLambda,
-  NIL
+  NIL,
+  TRUE_WORD,
+  FALSE_WORD,
+  BOOLEAN_SUBTYPE,
+  formatSubType,
+  PREDICATE
 } from './types.js'
 import {
   Brr,
@@ -48,7 +53,35 @@ 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],
@@ -93,6 +126,15 @@ export const setPropToAtom = (stats, prop) => {
     (stats[prop][0] = ATOM)
   )
 }
+export const setPropToPredicate = (stats, prop) => {
+  return (stats[prop][1] = BOOLEAN_SUBTYPE())
+}
+export const setReturnToPredicate = (stats) => {
+  return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
+}
+export const setTypeToPredicate = (stats) => {
+  return (stats[RETURNS][1] = BOOLEAN_SUBTYPE())
+}
 export const setPropToAbstraction = (stats, prop) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
@@ -202,6 +244,10 @@ 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 getSubReturn = (stats) => stats && stats[RETURNS][1]
+export const hasSubReturn = (stats) => stats && stats[RETURNS][1] instanceof Set
 export const isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
@@ -212,59 +258,70 @@ export const compareReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const compareTypeWithReturn = (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)) ||
+  (leaf[TYPE] === WORD &&
+    (leaf[VALUE] === TRUE_WORD ||
+      leaf[VALUE] === FALSE_WORD ||
+      leaf[VALUE] === NIL ||
+      getSuffix(leaf[VALUE]) === PREDICATE_SUFFIX)) ||
+  (leaf[TYPE] === APPLY &&
+    (PREDICATES_OUTPUT_SET.has(leaf[VALUE]) ||
+      getSuffix(leaf[VALUE]) === PREDICATE_SUFFIX))
+
+const notABooleanType = (a, b) =>
+  hasSubType(a) &&
+  getSubType(a).has(PREDICATE) &&
+  !isUnknownType(b) &&
+  !isAnyType(b) &&
+  (!hasSubType(b) || getSubType(a).difference(getSubType(b)).size !== 0)
+const notABooleanReturn = (a, b) =>
+  hasSubType(a) &&
+  getSubType(a).has(PREDICATE) &&
+  !isUnknownReturn(b) &&
+  !isAnyReturn(b) &&
+  (!hasSubReturn(b) || getSubType(a).difference(getSubReturn(b)).size !== 0)
+const isAtomABoolean = (atom) => atom === TRUE || atom === FALSE
 const checkPredicateName = (exp, rest) => {
   if (getSuffix(rest[0][VALUE]) === PREDICATE_SUFFIX) {
     const last = rest.at(-1)
-    if (isLeaf(last)) {
-      if (last[TYPE] === ATOM && last[VALUE] !== TRUE && last[VALUE] !== FALSE)
+    if (last[TYPE] !== APPLY && isLeaf(last) && !IsPredicate(last)) {
+      if (!IsPredicate(last))
         throw new TypeError(
-          `Assigning predicate (ending in ?) variable (${
+          `Assigning predicate (ending in ?) variable  (${
             rest[0][VALUE]
           }) to an (${
             STATIC_TYPES.ATOM
-          }) that is not (or ${TRUE} ${FALSE}) (${stringifyArgs(exp)})`
-        )
-      else if (
-        last[TYPE] === WORD &&
-        getSuffix(last[VALUE]) !== PREDICATE_SUFFIX &&
-        !PREDICATES_OUTPUT_SET.has(last[VALUE])
-      )
-        throw new TypeError(
-          `Assigning predicate (ending in ?) variable (${
-            rest[0][VALUE]
-          }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
+          }) that is not (or ${TRUE} ${FALSE}) or to another variable which is not a predicate (also ending in ?) or to a variable that is not (or true false nil) (${stringifyArgs(
             exp
-          )})`
+          )}) (check #100)`
         )
     } else if (last[0][0] === APPLY) {
       const application = last[0]
-      if (
-        application[VALUE] !== KEYWORDS.IF &&
-        getSuffix(application[VALUE]) !== PREDICATE_SUFFIX &&
-        !PREDICATES_OUTPUT_SET.has(application[VALUE])
-      )
+      if (application[VALUE] !== KEYWORDS.IF && !IsPredicate(application))
         throw new TypeError(
           `Assigning predicate (ending in ?) variable (${
             application[VALUE]
-          }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
+          })  to another variable which is not a predicate (also ending in ?) or to a variable that is not (or true false nil)  (${stringifyArgs(
             exp
-          )})`
+          )}) (check #101)`
         )
     }
+    return true
   }
+  return false
 }
 const checkPredicateNameDeep = (name, exp, rest, returns) => {
   if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
     const fn = rest.at(-1).at(-1).at(-1)
-    checkPredicateName(exp, [
+    return checkPredicateName(exp, [
       [WORD, name],
       isLeaf(fn)
         ? fn // when apply is a word (let x? (lambda (apply [] array:empty!)))
         : drillReturnType(fn, (r) => r[VALUE] === KEYWORDS.CALL_FUNCTION) // when apply is an annonymous lambda // (let fn? (lambda x (apply x (lambda x (array:empty! [])))))
     ])
-  } else {
-    checkPredicateName(exp, [[WORD, name], returns])
   }
+  return checkPredicateName(exp, [[WORD, name], returns])
 }
 const fillUknownArgs = (n) =>
   Array.from({ length: n })
@@ -420,31 +477,33 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
   if (returns[TYPE] === ATOM) {
     // ATOM ASSIGMENT
     setPropToAtom(env[name][STATS], prop)
-    checkPredicateName(exp, [[WORD, name], returns])
   } else {
     switch (returns[VALUE]) {
       case KEYWORDS.IF:
         resolveCondition({ rem, name, env, exp, prop })
         break
       default:
-        checkPredicateNameDeep(name, exp, exp.slice(1), returns)
-        if (!env[returns[VALUE]]) return false
-        else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
-          if (returns[TYPE] === WORD) setReturnToAbbstraction(env[name][STATS])
-          else {
-            // ALWAYS APPLY
-            // rest.at(-1)[0][TYPE] === APPLY
-            // Here is upon application to store the result in the variable
-            if (isUnknownType(env[name][STATS]))
-              stack.prepend(() => {
-                setTypeToReturn(env[name][STATS], env[returns[VALUE]][STATS])
-                // env[name][STATS][TYPE_PROP][0] =
-                //   env[returns[VALUE]][STATS][RETURNS][0]
-                // this seems to be able to be deleted
-                // env[name][STATS][TYPE_PROP][1] =
-                //   env[returns[VALUE]][STATS][RETURNS][1]
-              })
-            else setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
+        {
+          checkPredicateNameDeep(name, exp, exp.slice(1), returns)
+          if (!env[returns[VALUE]]) return false
+          else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
+            if (returns[TYPE] === WORD)
+              setReturnToAbbstraction(env[name][STATS])
+            else {
+              // ALWAYS APPLY
+              // rest.at(-1)[0][TYPE] === APPLY
+              // Here is upon application to store the result in the variable
+              if (isUnknownType(env[name][STATS]))
+                stack.prepend(() => {
+                  setTypeToReturn(env[name][STATS], env[returns[VALUE]][STATS])
+                  // env[name][STATS][TYPE_PROP][0] =
+                  //   env[returns[VALUE]][STATS][RETURNS][0]
+                  // this seems to be able to be deleted
+                  // env[name][STATS][TYPE_PROP][1] =
+                  //   env[returns[VALUE]][STATS][RETURNS][1]
+                })
+              else setReturnRef(env[name][STATS], env[returns[VALUE]][STATS])
+            }
           }
         }
         break
@@ -582,16 +641,18 @@ export const typeCheck = (ast, error = true) => {
                     retried: 0,
                     counter: 0,
                     [SIGNATURE]: name,
-                    [TYPE_PROP]: [
-                      isLeafNode
-                        ? right[TYPE]
-                        : env[right[VALUE]] == undefined
-                        ? UNKNOWN
-                        : env[right[VALUE]][STATS][RETURNS][0]
-                    ],
+                    [TYPE_PROP]: [UNKNOWN],
                     [RETURNS]: [UNKNOWN]
                   }
                 }
+                const type = isLeafNode
+                  ? right[TYPE]
+                  : env[right[VALUE]] == undefined
+                  ? UNKNOWN
+                  : 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]
@@ -776,88 +837,42 @@ export const typeCheck = (ast, error = true) => {
                 // also type of arg
                 const args = env[first[VALUE]][STATS][ARGUMENTS] ?? []
                 for (let i = 0; i < args.length; ++i) {
-                  const isRestILeaf = isLeaf(rest[i])
+                  const isResLeaf = isLeaf(rest[i])
                   // type check
                   // TODO get rof pred type
                   // const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
                   const MAIN_TYPE = getType(args[i][STATS])
                   if (MAIN_TYPE === ANY) continue
                   if (first[TYPE] === APPLY && isSpecial) {
-                    if (
-                      MAIN_TYPE === ATOM &&
-                      PREDICATES_INPUT_SET.has(first[VALUE])
-                    ) {
-                      if (
-                        !isRestILeaf &&
-                        rest[i][0][TYPE] === APPLY &&
-                        rest[i][0][VALUE] === KEYWORDS.CALL_FUNCTION
-                      ) {
-                        if (isLeaf(rest[i].at(-1))) {
-                          const fnName = rest[i].at(-1)[VALUE]
-                          const fn = env[fnName]
-                          if (fn && getReturn(fn[STATS]) !== ATOM)
-                            throw new TypeError(
-                              `Incorrect type of argument (${i}) for (${
-                                first[VALUE]
-                              }). Expected (${toTypeNames(
-                                ATOM
-                              )}) but got an (${toTypeNames(
-                                getReturn(fn[STATS])
-                              )}) (${stringifyArgs(exp)}) (check #26)`
-                            )
-                        } else {
-                          const body = rest[i].at(-1).at(-1)
-                          const rem = hasBlock(body) ? body.at(-1) : body
-                          const returns = isLeaf(rem) ? rem : rem[0]
-                          if (returns[TYPE] === ATOM) {
-                            if (MAIN_TYPE !== ATOM)
-                              throw new TypeError(
-                                `Incorrect type of argument ${i} for (${
-                                  first[VALUE]
-                                }). Expected (${toTypeNames(
-                                  MAIN_TYPE
-                                )}) but got an (${toTypeNames(
-                                  ATOM
-                                )})  (${stringifyArgs(exp)}) (check #27)`
-                              )
-                          } else if (
-                            env[returns[VALUE]] &&
-                            !isUnknownReturn(env[returns[VALUE]][STATS]) &&
-                            getReturn(env[returns[VALUE]][STATS]) !== ATOM
-                          )
-                            throw new TypeError(
-                              `Incorrect type of argument ${i} for (${
-                                first[VALUE]
-                              }). Expected (${toTypeNames(
-                                ATOM
-                              )}) but got (${toTypeNames(
-                                getReturn(env[returns[VALUE]][STATS])
-                              )})  (${stringifyArgs(exp)}) (check #29)`
-                            )
-                        }
-                      }
-                    }
-                    const expectedArgs = env[first[VALUE]][STATS][ARGUMENTS]
-                    if (!isRestILeaf) {
+                    if (!isResLeaf) {
                       const name = rest[i][0][VALUE]
                       if (!env[name]) continue
                       if (
                         !isUnknownReturn(env[name][STATS]) &&
-                        !compareTypeWithReturn(
-                          expectedArgs[i][STATS],
-                          env[name][STATS]
-                        )
+                        !compareTypeWithReturn(args[i][STATS], env[name][STATS])
                       )
                         throw new TypeError(
                           `Incorrect type of argument (${i}) for special form (${
                             first[VALUE]
                           }). Expected (${toTypeNames(
-                            getType(expectedArgs[i][STATS])
+                            getType(args[i][STATS])
                           )}) but got (${toTypeNames(
                             getReturn(env[name][STATS])
                           )}) (${stringifyArgs(exp)}) (check #1)`
                         )
-                      else {
+                      else if (
+                        notABooleanReturn(args[i][STATS], env[name][STATS])
+                      ) {
+                        throw new TypeError(
+                          `Incorrect type of argument (${i}) for special form (${
+                            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:
@@ -868,10 +883,7 @@ export const typeCheck = (ast, error = true) => {
                               // 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))
-                                setReturn(
-                                  env[name][STATS],
-                                  expectedArgs[i][STATS]
-                                )
+                                setReturn(env[name][STATS], args[i][STATS])
                               break
                           }
                         // TODO also handle casting
@@ -884,45 +896,64 @@ export const typeCheck = (ast, error = true) => {
                             if (!env[name]) continue
                             if (
                               !isUnknownType(env[name][STATS]) &&
-                              !compareTypes(
-                                expectedArgs[i][STATS],
-                                env[name][STATS]
-                              )
+                              !compareTypes(args[i][STATS], env[name][STATS])
                             )
                               throw new TypeError(
                                 `Incorrect type of argument (${i}) for special form (${
                                   first[VALUE]
                                 }). Expected (${toTypeNames(
-                                  getType(expectedArgs[i][STATS])
+                                  getType(args[i][STATS])
                                 )}) but got (${toTypeNames(
                                   getType(env[name][STATS])
                                 )}) (${stringifyArgs(exp)}) (check #3)`
                               )
-                            else
-                              setType(env[name][STATS], expectedArgs[i][STATS])
+                            else if (
+                              notABooleanType(args[i][STATS], env[name][STATS])
+                            )
+                              throw new TypeError(
+                                `Incorrect type of argument (${i}) for special form (${
+                                  first[VALUE]
+                                }). Expected (${formatSubType(
+                                  getTypes(args[i][STATS])
+                                )}) but got (${formatSubType(
+                                  getTypes(env[name][STATS])
+                                )}) (${stringifyArgs(exp)}) (check #202)`
+                              )
+                            else setType(env[name][STATS], args[i][STATS])
                           }
                           break
                         case ATOM: {
-                          if (
-                            rest[i][TYPE] !==
-                            expectedArgs[i][STATS][TYPE_PROP][0]
-                          )
+                          if (rest[i][TYPE] !== args[i][STATS][TYPE_PROP][0])
                             throw new TypeError(
                               `Incorrect type of argument (${i}) for special form (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
-                                expectedArgs[i][STATS][TYPE_PROP][0]
+                                args[i][STATS][TYPE_PROP][0]
                               )}) but got (${toTypeNames(
                                 rest[i][TYPE]
                               )}) (${stringifyArgs(exp)}) (check #2)`
                             )
+                          else if (
+                            hasSubType(args[i][STATS]) &&
+                            getSubType(args[i][STATS]).has(PREDICATE) &&
+                            !isAtomABoolean(rest[i][VALUE])
+                          )
+                            throw new TypeError(
+                              `Incorrect type of argument (${i}) for special form (${
+                                first[VALUE]
+                              }). Expected (${formatSubType(
+                                getTypes(args[i][STATS])
+                              )}) but got (${rest[i][VALUE]}) (${stringifyArgs(
+                                exp
+                              )}) (check #203)`
+                            )
                           break
                         }
                       }
                     }
                   }
                   // type checking
-                  else if (isRestILeaf) {
+                  else if (isResLeaf) {
                     const T =
                       rest[i][TYPE] === WORD
                         ? env[rest[i][VALUE]]

package/src/compiler.js

@@ -9,6 +9,7 @@ import {
   STATIC_TYPES
 } from './keywords.js'
 import { leaf, isLeaf, AST } from './parser.js'
+import { FALSE_WORD, TRUE_WORD } from './types.js'
 const deepRename = (name, newName, tree) => {
   if (!isLeaf(tree))
     for (const leaf of tree) {
@@ -40,6 +41,10 @@ const toCamelCase = (name) => {
 const dashToLodashes = (name) => name.replace(new RegExp(/-/g), '_')
 const keywordToHelper = (name) => {
   switch (name) {
+    case TRUE_WORD:
+      return '__true'
+    case FALSE_WORD:
+      return '__false'
     case KEYWORDS.ADDITION:
       return '__add'
     case KEYWORDS.MULTIPLICATION:

package/src/macros.js

@@ -246,8 +246,9 @@ export const deSuggarAst = (ast, scope) => {
                 break
               case KEYWORDS.MULTIPLICATION:
                 if (!rest.length) {
-                  exp[0][TYPE] = ATOM
-                  exp[0][VALUE] = TRUE
+                  // exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = KEYWORDS.NOT
+                  exp[1] = [ATOM, FALSE]
                 } else if (rest.length > 2) {
                   exp.length = 0
                   let temp = exp