fez-lisp 1.5.179 → 1.5.181

package/package.json

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

package/src/check.js

@@ -45,7 +45,8 @@ import {
   BOOLEAN,
   IS_ARGUMENT,
   NUMBER,
-  NUMBER_SUBTYPE
+  NUMBER_SUBTYPE,
+  UNKNOWN_SUBTYPE
 } from './types.js'
 import {
   Brr,
@@ -161,6 +162,7 @@ export const setProp = (stats, prop, value) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[prop][0] !== UNKNOWN &&
+    value[prop][0] !== ANY &&
     ((stats[prop][0] = value[prop][0]),
     value[prop][1] && (stats[prop][1] = value[prop][1]))
   )
@@ -169,6 +171,7 @@ export const setPropToReturn = (stats, prop, value) => {
   return (
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[RETURNS][0] !== UNKNOWN &&
+    value[RETURNS][0] !== ANY &&
     ((stats[prop][0] = value[RETURNS][0]),
     value[RETURNS][1] && (stats[prop][1] = value[RETURNS][1]))
   )
@@ -178,6 +181,7 @@ export const setPropToReturnRef = (stats, prop, value) => {
     stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
     value[RETURNS][0] !== UNKNOWN &&
+    value[RETURNS][0] !== ANY &&
     (stats[prop] = value[RETURNS])
   )
 }
@@ -185,6 +189,7 @@ export const setPropToType = (stats, prop, value) => {
   return (
     stats[prop] &&
     (stats[prop][0] === UNKNOWN || stats[prop][0] === ANY) &&
+    value[TYPE_PROP][0] !== ANY &&
     ((stats[prop][0] = value[TYPE_PROP][0]),
     value[TYPE_PROP][1] && (stats[prop][1] = value[TYPE_PROP][1]))
   )
@@ -726,7 +731,12 @@ const resolveGetter = ({ rem, prop, name, env }) => {
           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])
+          setPropToReturn(env[name][STATS], prop, env[array[VALUE]][STATS])
+          // TODO: handle this nested array overwrite better
+          if (getSubReturn(env[array[VALUE]][STATS]).has(COLLECTION))
+            setPropToSubReturn(env[name][STATS], prop, {
+              [RETURNS]: [COLLECTION, UNKNOWN_SUBTYPE()]
+            })
         } else return false
       } else return false
       break
@@ -741,7 +751,12 @@ const resolveGetter = ({ rem, prop, name, env }) => {
             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])
+            setPropToType(env[name][STATS], prop, env[array[VALUE]][STATS])
+            // TODO: handle this nested array overwrite better
+            if (getSubType(env[array[VALUE]][STATS]).has(COLLECTION))
+              setPropToSubType(env[name][STATS], prop, {
+                [TYPE_PROP]: [COLLECTION, UNKNOWN_SUBTYPE()]
+              })
           } else return false
         } else return false
       }
@@ -824,10 +839,11 @@ const resolveReturnType = ({
       default:
         {
           if (
+            !GETTERS_SET.has(name) &&
             GETTERS_SET.has(returns[VALUE]) &&
             !resolveGetter({ rem, prop, name, env })
           )
-            return once(env[name][STATS], [returns, env], stack, () => {
+            return retry(env[name][STATS], [returns, env], stack, () => {
               resolveReturnType({
                 returns,
                 rem,
@@ -1215,10 +1231,10 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
             }
             //  Predicate name consistency
             const rightHand = rest.at(-1)
+            const isApply =
+              rightHand && rightHand[0] && rightHand[0][TYPE] === APPLY
             if (
-              rightHand &&
-              rightHand[0] &&
-              rightHand[0][TYPE] === APPLY &&
+              isApply &&
               rightHand[0][VALUE] === KEYWORDS.ANONYMOUS_FUNCTION
             ) {
               validateLambda(rightHand, name)
@@ -1239,6 +1255,49 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                 retry(env[name][STATS], exp, stack, () =>
                   check(rightHand, env, exp)
                 )
+            } else if (
+              isApply &&
+              rightHand[0][VALUE] === KEYWORDS.CREATE_ARRAY
+            ) {
+              const right = rightHand[0]
+              env[name] = {
+                [STATS]: {
+                  [TYPE_PROP]: [COLLECTION],
+                  [RETURNS]: [UNKNOWN],
+                  [SIGNATURE]: name,
+                  retried: 0,
+                  counter: 0
+                }
+              }
+              setTypeToReturn(env[name][STATS], env[right[VALUE]][STATS])
+              const resolve = () => {
+                const body = rightHand
+                const rem = hasBlock(body) ? body.at(-1) : body
+                const returns = isLeaf(rem) ? rem : rem[0]
+                resolveReturnType({
+                  stack,
+                  returns,
+                  rem,
+                  prop: TYPE_PROP,
+                  exp,
+                  env,
+                  name,
+                  check
+                })
+              }
+              resolve()
+              if (isUknownSubType(env[name][STATS]))
+                stagger(stack, 'prepend', exp, () => {
+                  once(env[name][STATS], exp, stack, () => {
+                    setPropToCollection(env[name][STATS], TYPE_PROP)
+                    setPropToSubReturn(
+                      env[name][STATS],
+                      TYPE_PROP,
+                      initArrayType({ rem: rightHand, env })
+                    )
+                  })
+                })
+              check(rightHand, env, scope)
             } else {
               checkPredicateName(exp, rest)
               const isLeafNode = isLeaf(rightHand)
@@ -1455,7 +1514,7 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
             resolveSetter(first, rest, env, stack)
             // end of Var  ---------------
             // Judgement
-            stagger(stack, 'append', [first, env], () => {
+            const judge = () => {
               if (!isSpecial && env[first[VALUE]] === undefined)
                 throw new TypeError(
                   `Trying to call undefined (${KEYWORDS.ANONYMOUS_FUNCTION}) ${first[VALUE]} (check #9)`
@@ -1745,7 +1804,9 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                   }
                 }
               }
-            })
+            }
+            stagger(stack, 'append', [first, env], judge)
+            stagger(stack, 'prepend', [first, env], judge)
             for (let i = 0; i < rest.length; ++i) {
               const r = rest[i]
               if (isLeaf(r) && r[TYPE] !== ATOM)

package/src/types.js

@@ -36,6 +36,7 @@ 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])
+export const UNKNOWN_SUBTYPE = () => new Set([UNKNOWN])
 
 const SPECIAL_BOOLEAN = BOOLEAN_SUBTYPE()
 const SPECIAL_COLLECTION = COLLECTION_SUBTYPE()
@@ -56,7 +57,7 @@ export const toTypeNames = (type) => {
       return 'Unknown'
     case COLLECTION:
       // return 'Array'
-      return 'Unknowns'
+      return 'Unknown[]'
     case ANY:
       return 'Any'
     default:
@@ -75,13 +76,20 @@ export const toTypeCodes = (type) => {
       return [ATOM, NUMBER_SUBTYPE()]
     case 'Unknown':
       return [UNKNOWN]
+    case 'Unknown[]':
     case 'Unknowns':
     case 'Collection':
       return [COLLECTION, new Set([ANY])]
     case 'Numbers':
+    case 'Number[]':
       return [COLLECTION, NUMBER_SUBTYPE()]
     case 'Booleans':
+    case 'Boolean[]':
       return [COLLECTION, BOOLEAN_SUBTYPE()]
+    case 'Collections':
+    case 'Collection[]':
+    case 'Unknown[][]':
+      return [COLLECTION, COLLECTION_SUBTYPE()]
     case 'Any':
       return [ANY]
     default:
@@ -1300,7 +1308,7 @@ export const formatSubType = (T) => {
               )
               .join(' ') || toTypeNames(UNKNOWN)
           : toTypeNames(UNKNOWN)
-      }s`
+      }[]`
     case ATOM:
       return `${
         T[1] instanceof Set