fez-lisp 1.5.108 → 1.5.109

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.109",
   "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,
@@ -100,14 +103,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 +125,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 +175,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) =>
@@ -628,10 +640,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 +684,6 @@ export const typeCheck = (ast, error = true) => {
                   }
                 })
               }
-              // TODO overwrite return type check here
-            }
             check(rest.at(-1), copy, copy)
             break
           case STATIC_TYPES.ABSTRACTION:
@@ -1207,6 +1222,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/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)

package/src/types.js

@@ -1,4 +1,4 @@
-import { getReturn, getType } from './check.js'
+import { getReturn, getReturns, getType, getTypes } from './check.js'
 import {
   APPLY,
   ATOM,
@@ -19,8 +19,8 @@ export const TYPE_PROP = 'type'
 export const SIGNATURE = 'name'
 export const UNKNOWN = -1
 export const COLLECTION = 3
-export const PREDICATE = 4
-export const ANY = 5
+export const PREDICATE = 5
+export const ANY = 4
 export const ANONYMOUS_FUNCTION_TYPE_PREFIX = 'lambda::annonymous::'
 export const MAX_ARGUMENT_RETRY = 1
 export const MAX_RETRY_DEFINITION = 100
@@ -29,14 +29,13 @@ export const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
       return 'Abstraction'
+    case PREDICATE:
     case ATOM:
       return 'Atom'
     case UNKNOWN:
       return 'Unknown'
-    case PREDICATE:
-      return 'Predicate'
     case COLLECTION:
-      return 'Collection'
+      return '[]'
     case ANY:
       return 'Any'
     default:
@@ -100,7 +99,7 @@ export const SPECIAL_FORM_TYPES = {
   },
   [STATIC_TYPES.PREDICATE]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: STATIC_TYPES.PREDICATE,
       retried: Infinity,
       [ARG_COUNT]: 1,
@@ -117,7 +116,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [STATIC_TYPES.COLLECTION]: {
@@ -333,8 +332,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: 0,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -837,8 +836,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: 0,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -872,7 +871,7 @@ export const SPECIAL_FORM_TYPES = {
   },
   [KEYWORDS.NOT]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.NOT,
       retried: Infinity,
       [ARG_COUNT]: 1,
@@ -881,20 +880,20 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.EQUAL]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.EQUAL,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -922,12 +921,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.LESS_THAN]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       retried: Infinity,
       [SIGNATURE]: KEYWORDS.LESS_THAN,
       [ARG_COUNT]: 2,
@@ -955,12 +954,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.GREATHER_THAN]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.GREATHER_THAN,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -988,12 +987,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.GREATHER_THAN_OR_EQUAL]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.GREATHER_THAN_OR_EQUAL,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -1021,12 +1020,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.LESS_THAN_OR_EQUAL]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.LESS_THAN_OR_EQUAL,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -1054,12 +1053,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.AND]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.AND,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -1068,8 +1067,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -1079,20 +1078,20 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.OR]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.OR,
       retried: Infinity,
       [ARG_COUNT]: 2,
@@ -1101,8 +1100,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -1112,20 +1111,20 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: Infinity,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [ATOM, PREDICATE],
-            [RETURNS]: [ATOM, PREDICATE],
+            [TYPE_PROP]: [ATOM],
+            [RETURNS]: [ATOM],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.IS_ATOM]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.IS_ATOM,
       retried: Infinity,
       [ARG_COUNT]: 1,
@@ -1142,12 +1141,12 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.IS_LAMBDA]: {
     [STATS]: {
-      [TYPE_PROP]: [APPLY, PREDICATE],
+      [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.IS_LAMBDA,
       retried: Infinity,
       [ARG_COUNT]: 1,
@@ -1164,7 +1163,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [ATOM, PREDICATE]
+      [RETURNS]: [ATOM]
     }
   },
   [KEYWORDS.ERROR]: {
@@ -1191,6 +1190,22 @@ export const SPECIAL_FORM_TYPES = {
   }
 }
 
+const formatSubType = (T) => {
+  switch (T[0]) {
+    case COLLECTION:
+      return `[${
+        T[1] instanceof Set
+          ? [...T[1]]
+              .map((x) =>
+                x === COLLECTION ? formatSubType([x]) : toTypeNames(x)
+              )
+              .join(' ')
+          : toTypeNames(ANY)
+      }]`
+    default:
+      return toTypeNames(T[0])
+  }
+}
 export const formatType = (name, env) => {
   const stats = env[name][STATS]
   const isAnonymous = typeof name === 'number'
@@ -1205,15 +1220,15 @@ export const formatType = (name, env) => {
                   `${
                     getType(x[STATS]) === APPLY
                       ? `${formatType(i, stats[ARGUMENTS])}`
-                      : `${toTypeNamesAnyToUknown(getType(x[STATS]))}`
+                      : `${formatSubType(getTypes(x[STATS]))}`
                   }`
               ).join(' ') + ' '
             : ''
           // TODO format returned functions when type support is added
-        }(${KEYWORDS.BLOCK} ${toTypeNamesAnyToUknown(getReturn(stats))})${
+        }(${KEYWORDS.BLOCK} ${formatSubType(getReturns(stats))})${
           isAnonymous ? '' : ')'
         })`
-      : `(let ${name} ${toTypeNamesAnyToUknown(getType(stats))})`
+      : `(let ${name} ${formatSubType(getTypes(stats))})`
     : name
 }
 

package/src/utils.js

@@ -33,6 +33,7 @@ export const formatErrorWithCallstack = (error, callstack) =>
   `${error.message}\n${formatCallstack(callstack)}`
 // TODO figure out why name is sometimes undefined
 export const getSuffix = (str) => (str ? str[str.length - 1] : '')
+export const getPrefix = (str) => str?.split(':')[0]
 export const removeNoCode = (source) =>
   source
     .replace(/(;.+|;)/g, '')