fez-lisp 1.5.109 → 1.5.110

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.110",
   "type": "module",
   "main": "index.js",
   "keywords": [

package/src/check.js

@@ -38,7 +38,10 @@ import {
   formatType,
   ANONYMOUS_FUNCTION_TYPE_PREFIX,
   validateLambda,
-  NIL
+  NIL,
+  TRUE_WORD,
+  FALSE_WORD,
+  BOOLEAN_SUBTYPE
 } from './types.js'
 import {
   Brr,
@@ -93,6 +96,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) &&
@@ -212,59 +224,56 @@ 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 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 +429,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 +593,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]
@@ -783,60 +796,6 @@ export const typeCheck = (ast, error = true) => {
                   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) {
                       const name = rest[i][0][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

package/src/types.js

@@ -20,16 +20,23 @@ export const SIGNATURE = 'name'
 export const UNKNOWN = -1
 export const COLLECTION = 3
 export const PREDICATE = 5
+export const NUMBER = 6
 export const ANY = 4
 export const ANONYMOUS_FUNCTION_TYPE_PREFIX = 'lambda::annonymous::'
 export const MAX_ARGUMENT_RETRY = 1
 export const MAX_RETRY_DEFINITION = 100
 export const NIL = 'nil'
+export const TRUE_WORD = 'true'
+export const FALSE_WORD = 'false'
+export const BOOLEAN_SUBTYPE = () => new Set([PREDICATE])
 export const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
       return 'Abstraction'
     case PREDICATE:
+      return 'Boolean'
+    case NUMBER:
+      return 'Number'
     case ATOM:
       return 'Atom'
     case UNKNOWN:
@@ -110,13 +117,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [UNKNOWN],
             [RETURNS]: [UNKNOWN],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [STATIC_TYPES.COLLECTION]: {
@@ -836,7 +842,7 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: 0,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
             [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
@@ -849,7 +855,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ANY],
             [RETURNS]: [ANY],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -860,7 +865,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ANY],
             [RETURNS]: [ANY],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -880,15 +884,14 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
-            [RETURNS]: [ATOM],
-
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
+            [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()],
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.EQUAL]: {
@@ -904,7 +907,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -915,13 +917,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.LESS_THAN]: {
@@ -937,7 +938,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -948,13 +948,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.GREATHER_THAN]: {
@@ -981,13 +980,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.GREATHER_THAN_OR_EQUAL]: {
@@ -1003,7 +1001,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -1014,13 +1011,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.LESS_THAN_OR_EQUAL]: {
@@ -1036,7 +1032,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -1047,13 +1042,12 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [ATOM],
             [RETURNS]: [ATOM],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.AND]: {
@@ -1067,9 +1061,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
-            [RETURNS]: [ATOM],
-
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
+            [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()],
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -1078,15 +1071,14 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
-            [RETURNS]: [ATOM],
-
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
+            [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()],
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.OR]: {
@@ -1100,9 +1092,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
-            [RETURNS]: [ATOM],
-
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
+            [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()],
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -1111,15 +1102,14 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM],
-            [RETURNS]: [ATOM],
-
+            [TYPE_PROP]: [ATOM, BOOLEAN_SUBTYPE()],
+            [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()],
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.IS_ATOM]: {
@@ -1141,7 +1131,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.IS_LAMBDA]: {
@@ -1163,7 +1153,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM]
+      [RETURNS]: [ATOM, BOOLEAN_SUBTYPE()]
     }
   },
   [KEYWORDS.ERROR]: {
@@ -1202,6 +1192,12 @@ const formatSubType = (T) => {
               .join(' ')
           : toTypeNames(ANY)
       }]`
+    case ATOM:
+      return `${
+        T[1] instanceof Set
+          ? [...T[1]].map((x) => toTypeNames(x)).join(' ')
+          : toTypeNames(NUMBER)
+      }`
     default:
       return toTypeNames(T[0])
   }