fez-lisp 1.5.108 → 1.5.110

package/package.json

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

package/src/check.js

@@ -3,6 +3,9 @@ import {
   ATOM,
   FALSE,
   KEYWORDS,
+  MULTI_DIMENTIONAL_SETTERS,
+  MUTATION_SUFFIX,
+  MUTATORS_SET,
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   PREDICATES_INPUT_SET,
@@ -35,7 +38,10 @@ import {
   formatType,
   ANONYMOUS_FUNCTION_TYPE_PREFIX,
   validateLambda,
-  NIL
+  NIL,
+  TRUE_WORD,
+  FALSE_WORD,
+  BOOLEAN_SUBTYPE
 } from './types.js'
 import {
   Brr,
@@ -90,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) &&
@@ -100,14 +115,16 @@ export const setProp = (stats, prop, value) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[prop][0] !== UNKNOWN &&
-    (stats[prop][0] = value[prop][0])
+    ((stats[prop][0] = value[prop][0]),
+    value[prop][1] && (stats[prop][1] = value[prop][1]))
   )
 }
 export const setPropToReturn = (stats, prop, value) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[RETURNS][0] !== UNKNOWN &&
-    (stats[prop][0] = value[RETURNS][0])
+    ((stats[prop][0] = value[RETURNS][0]),
+    value[RETURNS][1] && (stats[prop][1] = value[RETURNS][1]))
   )
 }
 export const setPropToReturnRef = (stats, prop, value) => {
@@ -120,7 +137,8 @@ export const setPropToReturnRef = (stats, prop, value) => {
 export const setPropToType = (stats, prop, value) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
-    (stats[prop][0] = value[TYPE_PROP][0])
+    ((stats[prop][0] = value[TYPE_PROP][0]),
+    value[TYPE_PROP][1] && (stats[prop][1] = value[TYPE_PROP][1]))
   )
 }
 export const setPropToTypeRef = (stats, prop, value) => {
@@ -169,27 +187,33 @@ export const setReturn = (stats, value) => {
   return (
     isUnknownReturn(stats) &&
     !isUnknownReturn(value) &&
-    (stats[RETURNS][0] = value[RETURNS][0])
+    ((stats[RETURNS][0] = value[RETURNS][0]),
+    value[RETURNS][1] && (stats[RETURNS][1] = value[RETURNS][1]))
   )
 }
 export const setType = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   !isUnknownType(value) &&
-  (stats[TYPE_PROP][0] = value[TYPE_PROP][0])
+  ((stats[TYPE_PROP][0] = value[TYPE_PROP][0]),
+  value[TYPE_PROP][1] && (stats[TYPE_PROP][1] = value[TYPE_PROP][1]))
 export const setTypeToReturn = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   !isUnknownReturn(value) &&
-  (stats[TYPE_PROP][0] = value[RETURNS][0])
+  ((stats[TYPE_PROP][0] = value[RETURNS][0]),
+  value[RETURNS][1] && (stats[TYPE_PROP][1] = value[RETURNS][1]))
 export const setReturnToType = (stats, value) =>
   (isUnknownReturn(stats) || isAnyReturn(stats)) &&
   !isUnknownType(value) &&
-  (stats[RETURNS][0] = value[TYPE_PROP][0])
+  ((stats[RETURNS][0] = value[TYPE_PROP][0]),
+  value[TYPE_PROP][1] && (stats[RETURNS][1] = value[TYPE_PROP][1]))
 export const isAnyReturn = (stats) => stats && stats[RETURNS][0] === ANY
 export const isAnyType = (stats) => stats && stats[TYPE_PROP][0] === ANY
 export const isUnknownType = (stats) => stats && stats[TYPE_PROP][0] === UNKNOWN
 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 isAtomType = (stats) =>
   isAnyType(stats) || stats[TYPE_PROP][0] === ATOM
 export const isAtomReturn = (stats) =>
@@ -200,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 })
@@ -408,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
@@ -570,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]
@@ -628,10 +653,15 @@ export const typeCheck = (ast, error = true) => {
               const ref = env[copy[SCOPE_NAME]]
               if (!ref) continue
               ref[STATS][ARGUMENTS][i] = copy[param[VALUE]]
-              const returns = deepLambdaReturn(
-                hasBlock(exp) ? exp.at(-1) : exp,
-                (result) => result[VALUE] !== KEYWORDS.IF
-              )
+
+              // TODO overwrite return type check here
+            }
+            const returns = deepLambdaReturn(
+              hasBlock(exp) ? exp.at(-1) : exp,
+              (result) => result[VALUE] !== KEYWORDS.IF
+            )
+            const ref = env[copy[SCOPE_NAME]]
+            if (ref)
               if (isLeaf(returns))
                 // TODO figure out what we do here
                 // this here is a variable WORD
@@ -667,8 +697,6 @@ export const typeCheck = (ast, error = true) => {
                   }
                 })
               }
-              // TODO overwrite return type check here
-            }
             check(rest.at(-1), copy, copy)
             break
           case STATIC_TYPES.ABSTRACTION:
@@ -768,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]
@@ -1207,6 +1181,48 @@ export const typeCheck = (ast, error = true) => {
                     }
                     match()
                   }
+
+                  // handly typehints for arrays
+                  if (
+                    first[TYPE] === APPLY &&
+                    MUTATORS_SET.has(first[VALUE]) &&
+                    env[first[VALUE]]
+                  ) {
+                    const current = env[rest[i][VALUE]]
+                    if (current) {
+                      if (rest[i][TYPE] === WORD) {
+                        if (!current[STATS][TYPE_PROP][1]) {
+                          current[STATS][TYPE_PROP][1] = new Set()
+                        }
+                        if (MULTI_DIMENTIONAL_SETTERS.has(first[VALUE])) {
+                          current[STATS][TYPE_PROP][1].add(COLLECTION)
+                        } else {
+                          const right = isLeaf(rest.at(-1))
+                            ? rest.at(-1)
+                            : rest.at(-1)[0]
+                          switch (right[TYPE]) {
+                            case ATOM:
+                              current[STATS][TYPE_PROP][1].add(ATOM)
+                              break
+                            case WORD:
+                              if (env[right[VALUE]]) {
+                                current[STATS][TYPE_PROP][1].add(
+                                  ...env[right[VALUE]][STATS][TYPE_PROP]
+                                )
+                              }
+                              break
+                            case APPLY:
+                              if (env[right[VALUE]])
+                                current[STATS][TYPE_PROP][1].add(
+                                  ...env[right[VALUE]][STATS][RETURNS]
+                                )
+                              break
+                          }
+                        }
+                      }
+                    }
+                  }
+                  // handly typehints for arrays
                 }
               }
             })

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/enchance.js

@@ -8,7 +8,7 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { getSuffix, shake, wrapInBlock } from './utils.js'
+import { getPrefix, getSuffix, shake, wrapInBlock } from './utils.js'
 import std from '../lib/baked/std.js'
 export const OPTIMIZATIONS = {
   RECURSION: 'recursive',
@@ -47,7 +47,7 @@ export const enhance = (ast) => {
                     last[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
                   ) {
                     const name = exp[1][VALUE]
-                    const prefix = name.split(':')[0]
+                    const prefix = getPrefix(name)
                     if (prefix === OPTIMIZATIONS.RECURSION) {
                       const args = last.slice(1, -1)
                       const newName = `${OPTIMIZED_PREFIX}${name}::*${performance

package/src/keywords.js

@@ -97,3 +97,34 @@ export const PREDICATES_OUTPUT_SET = new Set([
   KEYWORDS.IS_ATOM,
   KEYWORDS.IS_LAMBDA
 ])
+export const MUTATORS_SET = new Set([
+  KEYWORDS.SET_ARRAY,
+  'set:with!',
+  'map:with!',
+  'matrix: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!',
+  'var:set!',
+  'array:merge!',
+  'list:merge!',
+  'list:concat!'
+])
+export const MULTI_DIMENTIONAL_SETTERS = new Set([
+  'set:with!',
+  'map:with!',
+  'matrix:set!',
+  'matrix:set-and-get!',
+  'array:set-and-get!',
+  'set:add!',
+  'map:set!',
+  'list:merge!',
+  'list:concat!'
+])

package/src/macros.js

@@ -10,6 +10,7 @@ import {
   FALSE,
   KEYWORDS,
   PLACEHOLDER,
+  STATIC_TYPES,
   TRUE,
   TYPE,
   VALUE,
@@ -77,6 +78,14 @@ export const deSuggarAst = (ast, scope) => {
               //       break
               case KEYWORDS.BLOCK:
                 {
+                  if (rest.length === 0)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        KEYWORDS.BLOCK
+                      }), expected (>= 1) but got (0) (${
+                        KEYWORDS.BLOCK
+                      } ${stringifyArgs(rest)})`
+                    )
                   if (
                     prev &&
                     prev[TYPE] === APPLY &&
@@ -151,12 +160,10 @@ export const deSuggarAst = (ast, scope) => {
                   let temp = exp
                   for (let i = 0; i < rest.length; i += 2) {
                     if (i === rest.length - 2) {
-                      temp.push(
-                        [APPLY, KEYWORDS.IF],
-                        rest[i],
-                        rest.at(-1),
-                        rest.at(-1)
-                      )
+                      temp.push([APPLY, KEYWORDS.IF], rest[i], rest.at(-1), [
+                        [APPLY, STATIC_TYPES.ANY],
+                        [WORD, NIL]
+                      ])
                     } else {
                       temp.push([APPLY, KEYWORDS.IF], rest[i], rest[i + 1], [])
                       temp = temp.at(-1)
@@ -239,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