fez-lisp 1.5.124 → 1.5.126

package/package.json

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

package/src/check.js

@@ -2,7 +2,10 @@ import {
   APPLY,
   ATOM,
   FALSE,
+  GETTERS_SET,
   KEYWORDS,
+  MUTATION_SUFFIX,
+  MUTATORS_SET,
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   PREDICATES_OUTPUT_SET,
@@ -40,13 +43,16 @@ import {
   BOOLEAN_SUBTYPE,
   formatSubType,
   PREDICATE,
-  IS_ARGUMENT
+  IS_ARGUMENT,
+  NUMBER,
+  SETTER
 } from './types.js'
 import {
   Brr,
   getSuffix,
   hasApplyLambdaBlock,
   hasBlock,
+  logExp,
   stringifyArgs
 } from './utils.js'
 Set.prototype.union = function (B) {
@@ -152,6 +158,7 @@ export const setPropToReturn = (stats, prop, value) => {
 }
 export const setPropToReturnRef = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[RETURNS][0] !== UNKNOWN &&
     (stats[prop] = value[RETURNS])
@@ -159,6 +166,7 @@ export const setPropToReturnRef = (stats, prop, value) => {
 }
 export const setPropToType = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     ((stats[prop][0] = value[TYPE_PROP][0]),
     value[TYPE_PROP][1] && (stats[prop][1] = value[TYPE_PROP][1]))
@@ -166,6 +174,7 @@ export const setPropToType = (stats, prop, value) => {
 }
 export const setPropToTypeRef = (stats, prop, value) => {
   return (
+    stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     (stats[prop] = value[TYPE_PROP])
   )
@@ -177,6 +186,9 @@ export const setReturnToAtom = (stats) => {
 }
 export const setTypeToAtom = (stats) =>
   (isUnknownType(stats) || isAnyType(stats)) && (stats[TYPE_PROP][0] = ATOM)
+export const setTypeToCollection = (stats) =>
+  (isUnknownType(stats) || isAnyType(stats)) &&
+  (stats[TYPE_PROP][0] = COLLECTION)
 export const setReturnToAbbstraction = (stats) =>
   isUnknownReturn(stats) && (stats[RETURNS][0] = APPLY)
 export const setTypeRef = (stats, value) =>
@@ -217,6 +229,15 @@ export const setType = (stats, value) =>
   !isUnknownType(value) &&
   ((stats[TYPE_PROP][0] = value[TYPE_PROP][0]),
   value[TYPE_PROP][1] && (stats[TYPE_PROP][1] = value[TYPE_PROP][1]))
+export const setSubType = (stats, value) =>
+  // makes no senseto protect this for now
+  hasSubType(value) && (stats[TYPE_PROP][1] = value[TYPE_PROP][1])
+export const setPropToSubType = (stats, prop, value) =>
+  // makes no senseto protect this for now
+  hasSubType(value) && (stats[prop][1] = value[TYPE_PROP][1])
+export const setPropToSubReturn = (stats, prop, value) =>
+  // makes no senseto protect this for now
+  hasSubType(value) && (stats[prop][1] = value[RETURNS][1])
 export const setTypeToReturn = (stats, value) =>
   (isUnknownType(stats) || isAnyType(stats)) &&
   !isUnknownReturn(value) &&
@@ -230,6 +251,10 @@ export const setReturnToType = (stats, value) =>
 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 isUnknownProp = (stats, prop) => {
+  return stats && stats[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]
@@ -266,9 +291,7 @@ const notABooleanType = (a, b) => {
     getSubType(a).has(PREDICATE) &&
     !isUnknownType(b) &&
     !isAnyType(b) &&
-    (!isAtomType(b) ||
-      !hasSubType(b) ||
-      getSubType(a).difference(getSubType(b)).size !== 0)
+    (!hasSubType(b) || getSubType(a).difference(getSubType(b)).size !== 0)
   )
 }
 const notABooleanReturn = (a, b) => {
@@ -482,6 +505,87 @@ const resolveCondition = ({ rem, name, env, exp, prop }) => {
       break
   }
 }
+const resolveSetter = (first, rest, env) => {
+  if (
+    getSuffix(first[VALUE]) === MUTATION_SUFFIX &&
+    MUTATORS_SET.has(first[VALUE]) &&
+    rest[0] &&
+    isLeaf(rest[0]) &&
+    rest[0][TYPE] !== ATOM &&
+    env[rest[0][VALUE]]
+  ) {
+    const name = rest[0][VALUE]
+    const current = env[name]
+    if (!hasSubType(current[STATS])) {
+      const right = isLeaf(rest.at(-1)) ? rest.at(-1) : rest.at(-1)[0]
+      switch (right[TYPE]) {
+        case ATOM:
+          current[STATS][TYPE_PROP][1] = new Set([NUMBER])
+          break
+        case WORD:
+          if (env[right[VALUE]]) {
+            if (hasSubType(env[right[VALUE]][STATS]))
+              current[STATS][TYPE_PROP][1] = new Set(
+                getSubType(env[right[VALUE]][STATS])
+              )
+            else
+              current[STATS][TYPE_PROP][1] = new Set([
+                getType(env[right[VALUE]][STATS])
+              ])
+          }
+          break
+        case APPLY:
+          if (env[right[VALUE]]) {
+            if (hasSubReturn(env[right[VALUE]][STATS]))
+              current[STATS][TYPE_PROP][1] = new Set([
+                ...getSubReturn(env[right[VALUE]][STATS])
+              ])
+            else
+              current[STATS][TYPE_PROP][1] = new Set([
+                env[right[VALUE]][STATS][RETURNS][0]
+              ])
+          }
+          break
+      }
+      setTypeToCollection(current[STATS])
+    }
+  }
+}
+const resolveGetter = ({ rem, prop, name, env }) => {
+  const array = isLeaf(rem[1]) ? rem[1] : rem[1][0]
+  if (!env[array[VALUE]] || !env[name]) return true
+  switch (array[TYPE]) {
+    case APPLY:
+      if (hasSubType(env[array[VALUE]][STATS])) {
+        const rightSub = getSubReturn(env[array[VALUE]][STATS])
+        const isAtom = rightSub.has(NUMBER) || rightSub.has(PREDICATE)
+        const isCollection = rightSub.has(COLLECTION)
+        if (isAtom && !isCollection) {
+          setPropToAtom(env[name][STATS], prop)
+          setPropToSubReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
+        } else if (!isAtom && isCollection) {
+          setPropToReturn(env[name][STATS], env[array[VALUE]][STATS])
+        }
+      } else return false
+      break
+    case WORD:
+      {
+        if (hasSubType(env[array[VALUE]][STATS])) {
+          const rightSub = getSubType(env[array[VALUE]][STATS])
+          const isAtom = rightSub.has(NUMBER) || rightSub.has(PREDICATE)
+          const isCollection = rightSub.has(COLLECTION)
+          if (isAtom && !isCollection) {
+            setPropToAtom(env[name][STATS], prop)
+            setPropToSubType(env[name][STATS], prop, env[array[VALUE]][STATS])
+          } else if (!isAtom && isCollection) {
+            setPropToType(env[name][STATS], env[array[VALUE]][STATS])
+          }
+        } else return false
+      }
+      break
+  }
+  return true
+}
 const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
   if (returns[TYPE] === ATOM) {
     // ATOM ASSIGMENT
@@ -493,6 +597,21 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
         break
       default:
         {
+          if (
+            GETTERS_SET.has(returns[VALUE]) &&
+            !resolveGetter({ rem, prop, name, env })
+          )
+            return retry(env[name][STATS], stack, () => {
+              resolveRetunType({
+                returns,
+                rem,
+                stack,
+                prop,
+                exp,
+                name,
+                env
+              })
+            })
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
           if (!env[returns[VALUE]]) return false
           else if (getType(env[returns[VALUE]][STATS]) === APPLY) {
@@ -508,11 +627,6 @@ const resolveRetunType = ({ returns, rem, stack, prop, exp, name, env }) => {
                     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])
             }
@@ -567,6 +681,8 @@ export const typeCheck = (ast) => {
         break
       case APPLY: {
         switch (first[VALUE]) {
+          // Var
+          // ---------------
           case KEYWORDS.DEFINE_VARIABLE:
             if (rest.length !== 2)
               throw new TypeError(
@@ -778,6 +894,12 @@ export const typeCheck = (ast) => {
             }
             break
           default:
+            // Setters are just like DEFINE_VARIABLE as they are essentially the Var case for Collections
+            // So they MUST happen before Judgement
+            resolveSetter(first, rest, env)
+            // end of Var  ---------------
+
+            // Judgement
             stack.append(() => {
               if (!isSpecial && env[first[VALUE]] === undefined)
                 throw new TypeError(
@@ -915,7 +1037,6 @@ export const typeCheck = (ast) => {
                                 setReturnRef(env[name][STATS], args[i][STATS])
                               break
                           }
-
                         // TODO also handle casting
                       }
                     } else {
@@ -1331,47 +1452,6 @@ export const typeCheck = (ast) => {
                     }
                     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 → enhance.js}

@@ -16,7 +16,7 @@ const deepTransform = (predicate, transform, tree) => {
       else deepTransform(predicate, transform, leaf)
     }
 }
-export const enhance = (ast) => {
+const opt = (ast) => {
   const evaluate = (exp) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first != undefined) {
@@ -213,11 +213,12 @@ export const enhance = (ast) => {
         default:
           break
       }
-
       for (const r of rest) evaluate(r)
     }
   }
-  evaluate(AST.parse(AST.stringify(ast)))
+  evaluate(ast)
   const shaked = shake(ast[1][1].slice(1), std)
   return wrapInBlock(shaked)
 }
+
+export const enhance = (ast) => opt(AST.parse(AST.stringify(ast))[0])

package/src/keywords.js

@@ -99,8 +99,6 @@ export const PREDICATES_OUTPUT_SET = new Set([
 ])
 export const MUTATORS_SET = new Set([
   KEYWORDS.SET_ARRAY,
-  'set:with!',
-  'map:with!',
   'matrix:set!',
   'matrix:set-and-get!',
   'array:set-and-get!',
@@ -112,19 +110,19 @@ export const MUTATORS_SET = new Set([
   'array:set!',
   'array:append!',
   'array:push!',
-  'var:set!',
-  'array:merge!',
-  'list:merge!',
-  'list:concat!'
+  'var:set!'
 ])
-export const MULTI_DIMENTIONAL_SETTERS = new Set([
-  'set:with!',
-  'map:with!',
-  'matrix:set!',
+export const GETTERS_SET = new Set([
+  KEYWORDS.GET_ARRAY,
+  'matrix:get',
   'matrix:set-and-get!',
   'array:set-and-get!',
-  'set:add!',
-  'map:set!',
-  'list:merge!',
-  'list:concat!'
+  'var:set-and-get!',
+  'map:set-and-get!',
+  'set:add-and-get!',
+  'set:get',
+  'map:get',
+  'array:get',
+  'array:pop!',
+  'var:get'
 ])

package/src/types.js

@@ -30,6 +30,9 @@ export const NIL = 'nil'
 export const TRUE_WORD = 'true'
 export const FALSE_WORD = 'false'
 export const BOOLEAN_SUBTYPE = () => new Set([PREDICATE])
+export const ANY_SUBTYPE = () => new Set([ANY])
+export const COLLECTION_SUBTYPE = () => new Set([COLLECTION])
+export const NUMBER_SUBTYPE = () => new Set([NUMBER])
 
 export const toTypeNames = (type) => {
   switch (type) {
@@ -37,15 +40,16 @@ export const toTypeNames = (type) => {
       return 'Abstraction'
     case PREDICATE:
       return 'Boolean'
+    case ATOM:
     case NUMBER:
       return 'Number'
-    case ATOM:
-      return 'Atom'
+    // case ATOM:
+    //   return 'Atom'
     case UNKNOWN:
       return 'Unknown'
     case COLLECTION:
-      return 'Array'
-    // return '[]'
+      // return 'Array'
+      return '[Unknown]'
     case ANY:
       return 'Any'
     default:
@@ -60,6 +64,8 @@ export const toTypeNamesAnyToUknown = (type) => {
       return toTypeNames(type)
   }
 }
+export const GETTER = 1
+export const SETTER = 2
 export const SPECIAL_FORM_TYPES = {
   [SCOPE_NAME]: ';',
   // [ORDER]: 0,
@@ -718,6 +724,7 @@ export const SPECIAL_FORM_TYPES = {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
       [SIGNATURE]: KEYWORDS.GET_ARRAY,
+      tag: GETTER,
       retried: Infinity,
       [ARG_COUNT]: 2,
       [ARGUMENTS]: [
@@ -750,6 +757,7 @@ export const SPECIAL_FORM_TYPES = {
   [KEYWORDS.SET_ARRAY]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
+      tag: SETTER,
       retried: Infinity,
       [ARG_COUNT]: 3,
       [ARGUMENTS]: [
@@ -757,8 +765,8 @@ export const SPECIAL_FORM_TYPES = {
           [STATS]: {
             retried: 0,
             [SIGNATURE]: PLACEHOLDER,
-            [TYPE_PROP]: [COLLECTION],
-            [RETURNS]: [COLLECTION],
+            [TYPE_PROP]: [COLLECTION, ANY_SUBTYPE()],
+            [RETURNS]: [COLLECTION, ANY_SUBTYPE()],
 
             [ARGUMENTS]: [],
             [ARG_COUNT]: 0
@@ -787,7 +795,7 @@ export const SPECIAL_FORM_TYPES = {
           }
         }
       ],
-      [RETURNS]: [COLLECTION]
+      [RETURNS]: [COLLECTION, ANY_SUBTYPE()]
     }
   },
   [KEYWORDS.POP_ARRAY]: {
@@ -1185,18 +1193,18 @@ export const SPECIAL_FORM_TYPES = {
 
 export const formatSubType = (T) => {
   switch (T[0]) {
-    // case COLLECTION:
-    //   return `[${
-    //     T[1] instanceof Set
-    //       ? [...T[1]]
-    //           .map((x) =>
-    //             x === COLLECTION
-    //               ? formatSubType([x])
-    //               : toTypeNamesAnyToUknown(x)
-    //           )
-    //           .join(' ')
-    //       : toTypeNamesAnyToUknown(ANY)
-    //   }]`
+    case COLLECTION:
+      return `[${
+        T[1] instanceof Set
+          ? [...T[1]]
+              .map((x) =>
+                x === COLLECTION
+                  ? formatSubType([x])
+                  : toTypeNamesAnyToUknown(x)
+              )
+              .join(' ')
+          : toTypeNamesAnyToUknown(ANY)
+      }]`
     case ATOM:
       return `${
         T[1] instanceof Set

package/src/utils.js

@@ -15,13 +15,13 @@ import {
   deSuggarSource,
   handleUnbalancedQuotes
 } from './macros.js'
-import { OPTIMIZATIONS } from './enchance.js'
+import { OPTIMIZATIONS } from './enhance.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log('\x1b[32m', output, '\x1b[0m')
 export const wrapInBracesString = (exp) => `(${stringifyArgs(exp)})`
-export const logExp = function (exp, marker = ':D') {
-  console.log(marker, wrapInBracesString(exp), ...[...arguments].slice(2))
+export const logExp = function (exp, ...args) {
+  console.log(wrapInBracesString(exp), ...args)
   return exp
 }
 export const formatCallstack = (callstack) =>
@@ -457,6 +457,14 @@ export class Brr {
     for (let i = half; i < initial.length; ++i) this._addToRight(initial[i])
     return this
   }
+  // reverse() {
+  //   const left = this._left
+  //   const right = this._right
+  //   right.unshift(left.shift())
+  //   this._left = right
+  //   this._right = left
+  //   return this
+  // }
   *[Symbol.iterator]() {
     for (let i = 0, len = this.length; i < len; ++i) yield this.get(i)
   }