fez-lisp 1.5.145 → 1.5.147

package/package.json

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

package/src/check.js

@@ -17,7 +17,7 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { isLeaf } from './parser.js'
+import { isLeaf, LISP } from './parser.js'
 import {
   SPECIAL_FORM_TYPES,
   toTypeNames,
@@ -304,7 +304,7 @@ export const isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
   isAnyType(stats) || stats[RETURNS][0] === ATOM
-export const equalsTypes = (a, b) => {
+export const equalTypes = (a, b) => {
   const isAnyAny = isAnyType(a) || isAnyType(b)
   if (isAnyAny) return true
   const isSameType = a[TYPE_PROP][0] === b[TYPE_PROP][0]
@@ -312,7 +312,7 @@ export const equalsTypes = (a, b) => {
   return true
 }
 
-export const equalsReturns = (a, b) =>
+export const equalReturns = (a, b) =>
   isAnyReturn(a) || isAnyReturn(b) || a[RETURNS][0] === b[RETURNS][0]
 export const equalsTypeWithReturn = (a, b) =>
   isAnyType(a) || isAnyReturn(b) || a[TYPE_PROP][0] === b[RETURNS][0]
@@ -338,6 +338,39 @@ const notABooleanType = (a, b) => {
       (hasSubType(b) && getSubType(a).difference(getSubType(b)).size !== 0))
   )
 }
+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
+  )
+}
+const eualSubReturn = (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
+  )
+}
+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
+  )
+}
 const notABooleanTypeWithReturn = (a, b) => {
   return (
     hasSubType(a) &&
@@ -498,7 +531,6 @@ const IfApplyBranch = ({ leaf, branch, re, prop, ref, env }) => {
   }
 }
 const ifExpression = ({ re, env, ref, prop }) => {
-  // console.log(ref, JSON.stringify(env[KEYWORDS.IF][STATS][RETURNS]))
   if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM)
     return setPropToAtom(ref[STATS], prop)
   // TODO check that both brancehs are predicates if one is
@@ -669,7 +701,7 @@ const initArrayType = ({ rem, env }) => {
           ? env[x[VALUE]]
             ? getTypes(env[x[VALUE]][STATS])
             : [UNKNOWN]
-          : [x[TYPE]]
+          : [x[TYPE], x[TYPE] === ATOM ? NUMBER_SUBTYPE() : new Set([UNKNOWN])]
         : env[x[0][VALUE]]
         ? getReturns(env[x[0][VALUE]][STATS])
         : [UNKNOWN]
@@ -688,7 +720,7 @@ const initArrayType = ({ rem, env }) => {
   } else
     return {
       [TYPE_PROP]: [APPLY],
-      [RETURNS]: [COLLECTION, new Set([])]
+      [RETURNS]: [COLLECTION, new Set([UNKNOWN])]
     }
 }
 const resolveReturnType = ({
@@ -848,7 +880,6 @@ const checkReturnType = ({ exp, stack, name, env, check }) => {
   })
 }
 const stagger = (stack, method, data, fn) => {
-  // console.log(data[0], data[1])
   stack[method]({ data, fn })
 }
 export const typeCheck = (ast) => {
@@ -877,7 +908,7 @@ export const typeCheck = (ast) => {
             exp
           )}) (check #16)`
         )
-      else if (notABooleanTypeWithReturn(expected, actual)) {
+      else if (!equalSubTypesWithSubReturn(expected, actual)) {
         throw new TypeError(
           `Incorrect type of argument (${i}) for (${
             first[VALUE]
@@ -929,7 +960,7 @@ export const typeCheck = (ast) => {
                     if (
                       !isUnknownReturn(expected[STATS]) &&
                       !isUnknownReturn(actual[STATS]) &&
-                      !equalsReturns(expected[STATS], actual[STATS])
+                      !equalReturns(expected[STATS], actual[STATS])
                     )
                       throw new TypeError(
                         `Incorrect return type for (${
@@ -970,7 +1001,7 @@ export const typeCheck = (ast) => {
                       if (
                         !isUnknownType(actual[STATS]) &&
                         !isUnknownType(expected[STATS]) &&
-                        !equalsTypes(actual[STATS], expected[STATS])
+                        !equalTypes(actual[STATS], expected[STATS])
                       )
                         throw new TypeError(
                           `Incorrect type for (${
@@ -1137,8 +1168,8 @@ export const typeCheck = (ast) => {
                     [SIGNATURE]: name,
                     retried: 0,
                     counter: 0,
-                    [TYPE_PROP]: [ATOM],
-                    [RETURNS]: [ATOM]
+                    [TYPE_PROP]: [ATOM, NUMBER_SUBTYPE()],
+                    [RETURNS]: [ATOM, NUMBER_SUBTYPE()]
                   }
                 }
               } else if (rightHand[0]) {
@@ -1266,6 +1297,10 @@ export const typeCheck = (ast) => {
           case STATIC_TYPES.BOOLEAN:
           case STATIC_TYPES.ANY:
           case STATIC_TYPES.NUMBER:
+          case STATIC_TYPES.NUMBERS:
+          case STATIC_TYPES.ABSTRACTIONS:
+          case STATIC_TYPES.BOOLEANS:
+          case STATIC_TYPES.COLLECTIONS:
             {
               const ret = isLeaf(rest[0]) ? rest[0] : rest[0][0]
               const ref = env[ret[VALUE]]
@@ -1397,10 +1432,15 @@ export const typeCheck = (ast) => {
                                   )
                               }
                             }
-                            if (
-                              isKnown &&
-                              !equalsTypes(args[i][STATS], env[name][STATS])
+                            const eqTypes = equalTypes(
+                              args[i][STATS],
+                              env[name][STATS]
+                            )
+                            const eqSubTypes = equalSubTypes(
+                              args[i][STATS],
+                              env[name][STATS]
                             )
+                            if (isKnown && !eqTypes)
                               throw new TypeError(
                                 `Incorrect type of argument (${i}) for (${
                                   first[VALUE]
@@ -1410,11 +1450,7 @@ export const typeCheck = (ast) => {
                                   getType(env[name][STATS])
                                 )}) (${stringifyArgs(exp)}) (check #3)`
                               )
-                            else if (
-                              isKnown &&
-                              notABooleanType(args[i][STATS], env[name][STATS])
-                              // TODO: Add a check if subtype is a UKNOWN (for uknown array)
-                            )
+                            else if (isKnown && eqTypes && !eqSubTypes) {
                               throw new TypeError(
                                 `Incorrect type of argument (${i}) for (${
                                   first[VALUE]
@@ -1424,6 +1460,7 @@ export const typeCheck = (ast) => {
                                   getTypes(env[name][STATS])
                                 )}) (${stringifyArgs(exp)}) (check #202)`
                               )
+                            }
                           }
                           break
                         case ATOM:
@@ -1510,7 +1547,7 @@ export const typeCheck = (ast) => {
                               if (
                                 !isUnknownReturn(expected[STATS]) &&
                                 !isUnknownReturn(actual[STATS]) &&
-                                !equalsReturns(expected[STATS], actual[STATS])
+                                !equalReturns(expected[STATS], actual[STATS])
                               ) {
                                 throw new TypeError(
                                   `Incorrect return type for (${
@@ -1545,7 +1582,7 @@ export const typeCheck = (ast) => {
                                 if (
                                   !isUnknownType(actual[STATS]) &&
                                   !isUnknownType(expected[STATS]) &&
-                                  !equalsTypes(actual[STATS], expected[STATS])
+                                  !equalTypes(actual[STATS], expected[STATS])
                                 )
                                   throw new TypeError(
                                     `Incorrect type for (${
@@ -1580,8 +1617,8 @@ export const typeCheck = (ast) => {
                           // when it's a special form and it's not equal
                           // or failed the boolean subtype case
                           isSpecial &&
-                          (!equalsTypes(args[i][STATS], env[name][STATS]) ||
-                            !notABooleanType(args[i][STATS], env[name][STATS]))
+                          (!equalTypes(args[i][STATS], env[name][STATS]) ||
+                            !equalSubTypes(args[i][STATS], env[name][STATS]))
                         )
                           setType(env[name][STATS], args[i][STATS])
                         else if (
@@ -1616,8 +1653,8 @@ export const typeCheck = (ast) => {
                       if (isSpecial && name === KEYWORDS.IF) {
                         const concequent = [...rest]
                         const alternative = [...rest]
-                        concequent[i] = rest[i][1]
-                        alternative[i] = rest[i][2]
+                        concequent[i] = rest[i][2]
+                        alternative[i] = rest[i][3]
                         check([first, ...concequent], env, scope)
                         check([first, ...alternative], env, scope)
                       }

package/src/compiler.js

@@ -49,6 +49,10 @@ const keywordToHelper = (name) => {
     case STATIC_TYPES.BOOLEAN:
     case STATIC_TYPES.ANY:
     case STATIC_TYPES.NUMBER:
+    case STATIC_TYPES.NUMBERS:
+    case STATIC_TYPES.ABSTRACTIONS:
+    case STATIC_TYPES.BOOLEANS:
+    case STATIC_TYPES.COLLECTIONS:
     case DEBUG.ASSERT:
     case DEBUG.LOG:
     case DEBUG.STRING:
@@ -287,6 +291,10 @@ const comp = (tree, Drill) => {
       case STATIC_TYPES.BOOLEAN:
       case STATIC_TYPES.ANY:
       case STATIC_TYPES.NUMBER:
+      case STATIC_TYPES.NUMBERS:
+      case STATIC_TYPES.ABSTRACTIONS:
+      case STATIC_TYPES.BOOLEANS:
+      case STATIC_TYPES.COLLECTIONS:
       case DEBUG.ASSERT:
       case DEBUG.LOG:
       case DEBUG.STRING:

package/src/enhance.js

@@ -1,5 +1,13 @@
 import { AST, isLeaf } from './parser.js'
-import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
+import {
+  APPLY,
+  ATOM,
+  KEYWORDS,
+  STATIC_TYPES,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
 import { getPrefix, shake, wrapInBlock } from './utils.js'
 import std from '../lib/baked/std.js'
 export const OPTIMIZATIONS = {
@@ -28,6 +36,22 @@ const opt = (ast) => {
         case APPLY:
           {
             switch (first[VALUE]) {
+              case STATIC_TYPES.ABSTRACTION:
+              case STATIC_TYPES.COLLECTION:
+              case STATIC_TYPES.UNKNOWN:
+              case STATIC_TYPES.ATOM:
+              case STATIC_TYPES.BOOLEAN:
+              case STATIC_TYPES.ANY:
+              case STATIC_TYPES.NUMBER:
+              case STATIC_TYPES.NUMBERS:
+              case STATIC_TYPES.ABSTRACTIONS:
+              case STATIC_TYPES.BOOLEANS:
+              case STATIC_TYPES.COLLECTIONS:
+              case STATIC_TYPES.AS_NUMBER:
+                exp.length = 0
+                for (let i = 0; i < rest.length; ++i) exp.push(...rest[i])
+                evaluate(exp)
+                break
               case KEYWORDS.DEFINE_VARIABLE:
                 {
                   const last = exp.at(-1)

package/src/interpreter.js

@@ -833,11 +833,17 @@ export const keywords = {
     throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   },
 
-  [STATIC_TYPES.ABSTRACTION]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.UNKNOWN]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.ANY]: (args, env) => evaluate(args[0], env),
+
   [STATIC_TYPES.ATOM]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.ABSTRACTION]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.COLLECTION]: (args, env) => evaluate(args[0], env),
+
   [STATIC_TYPES.BOOLEAN]: (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)
+  [STATIC_TYPES.NUMBERS]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.COLLECTIONS]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.ABSTRACTIONS]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.BOOLEANS]: (args, env) => evaluate(args[0], env)
 }

package/src/keywords.js

@@ -15,6 +15,11 @@ export const STATIC_TYPES = {
   ATOM: 'Atom',
   COLLECTION: 'Collection',
   BOOLEAN: 'Boolean',
+  NUMBERS: 'Numbers',
+  BOOLEANS: 'Booleans',
+  ABSTRACTIONS: 'Abstractions',
+  COLLECTIONS: 'Collections',
+  AS_NUMBER: 'numberp',
   ANY: 'Any'
 }
 export const KEYWORDS = {
@@ -104,10 +109,6 @@ export const MUTATORS_SET = new Set([
   'matrix:set-and-get!',
   'array:set-and-get!',
   'var:set-and-get!',
-  'map:set-and-get!',
-  'set:add-and-get!',
-  'set:add!',
-  'map:set!',
   'array:set!',
   'array:append!',
   'array:push!',

package/src/macros.js

@@ -324,8 +324,11 @@ export const deSuggarAst = (ast, scope) => {
                 break
               case KEYWORDS.DIVISION:
                 if (!rest.length) {
-                  exp[0][TYPE] = ATOM
-                  exp[0][VALUE] = FALSE
+                  exp[0][VALUE] = KEYWORDS.NOT
+                  exp[1] = [
+                    [APPLY, KEYWORDS.NOT],
+                    [ATOM, FALSE]
+                  ]
                 } else if (rest.length === 1) {
                   exp.length = 1
                   exp.push([ATOM, 1], rest[0])

package/src/types.js

@@ -33,10 +33,12 @@ 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])
 
 const SPECIAL_BOOLEAN = BOOLEAN_SUBTYPE()
 const SPECIAL_COLLECTION = COLLECTION_SUBTYPE()
 const SPECIAL_NUMBER = NUMBER_SUBTYPE()
+const SPECIAL_ABSTRACTION = ABSTRACTION_SUBTYPE()
 export const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
@@ -85,7 +87,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [UNKNOWN],
             [RETURNS]: [UNKNOWN],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -94,6 +95,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [APPLY]
     }
   },
+  [STATIC_TYPES.ABSTRACTIONS]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.ABSTRACTIONS,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [COLLECTION, SPECIAL_ABSTRACTION]
+    }
+  },
   [STATIC_TYPES.ATOM]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -107,7 +129,6 @@ export const SPECIAL_FORM_TYPES = {
             [SIGNATURE]: PLACEHOLDER,
             [TYPE_PROP]: [UNKNOWN],
             [RETURNS]: [UNKNOWN],
-
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
@@ -116,6 +137,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM]
     }
   },
+  [STATIC_TYPES.AS_NUMBER]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.AS_NUMBER,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [ATOM, SPECIAL_BOOLEAN],
+            [RETURNS]: [ATOM, SPECIAL_BOOLEAN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [ATOM, SPECIAL_NUMBER]
+    }
+  },
   [STATIC_TYPES.BOOLEAN]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -137,6 +179,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM, SPECIAL_BOOLEAN]
     }
   },
+  [STATIC_TYPES.BOOLEANS]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.BOOLEANS,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [COLLECTION, SPECIAL_BOOLEAN]
+    }
+  },
   [STATIC_TYPES.NUMBER]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -158,6 +221,27 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM, SPECIAL_NUMBER]
     }
   },
+  [STATIC_TYPES.NUMBERS]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.NUMBERS,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [COLLECTION, SPECIAL_NUMBER]
+    }
+  },
   [STATIC_TYPES.COLLECTION]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -180,6 +264,28 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [COLLECTION]
     }
   },
+  [STATIC_TYPES.COLLECTIONS]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.COLLECTIONS,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [COLLECTION, SPECIAL_COLLECTION]
+    }
+  },
   [STATIC_TYPES.UNKNOWN]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],