fez-lisp 1.6.59 → 1.6.61

package/package.json

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

package/src/check.js

@@ -56,7 +56,9 @@ import {
   hasBlock,
   log,
   logExp,
-  stringifyArgs
+  stringifyArgs,
+  wrapInApplyLambda,
+  wrapInBlock
 } from './utils.js'
 
 export const identity = (name) => [
@@ -603,10 +605,9 @@ const resolveCondition = ({ rem, name, env, exp, prop, stack, check }) => {
 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])) {
+      if (hasSubReturn(env[array[VALUE]][STATS])) {
         const rightSub = getSubReturn(env[array[VALUE]][STATS])
         const isAtom = rightSub.has(NUMBER) || rightSub.has(BOOLEAN)
         const isCollection = rightSub.has(COLLECTION)
@@ -614,12 +615,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], 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()]
-            })
+          setPropToReturn(env[name][STATS], prop, {
+            [RETURNS]: [
+              env[array[VALUE]][STATS][RETURNS][1].types[0],
+              new SubType(env[array[VALUE]][STATS][RETURNS][1].types.slice(1))
+            ]
+          })
         } else return false
       } else return false
       break
@@ -713,10 +714,12 @@ const resolveSetter = (first, rest, env, stack) => {
       case APPLY:
         if (env[right[VALUE]]) {
           if (right[VALUE] === KEYWORDS.CREATE_ARRAY) {
-            current[STATS][TYPE_PROP][1] = initArrayType({
+            const inner = initArrayType({
               rem: rest.at(-1),
               env
             })[RETURNS][1]
+            current[STATS][TYPE_PROP][0] = COLLECTION
+            if (!inner.has(UNKNOWN)) current[STATS][TYPE_PROP][1] = inner
             break
           }
           if (hasSubReturn(env[right[VALUE]][STATS])) {
@@ -782,7 +785,6 @@ const initArrayTypeRec = ({ rem, env }) => {
 const initArrayType = ({ rem, env }) => {
   const ret = initArrayTypeRec({ rem, env })
   const known = ret.find((x) => x[0] !== ANY && x[0] !== UNKNOWN)
-  // console.log(known[0], ret[0])
   if (known && ret.length) {
     if (Array.isArray(ret[0][0])) {
       let head = ret[0][0]
@@ -796,6 +798,7 @@ const initArrayType = ({ rem, env }) => {
       if (head) subT.add(head[1].types[0])
     }
     const [main, sub] = ret[0]
+    if (isSubType(sub) && sub.types.at(-1) === COLLECTION) sub.types.pop()
     return {
       [TYPE_PROP]: [APPLY],
       [RETURNS]: [COLLECTION, new SubType(isSubType(sub) ? [...sub] : [main])]
@@ -1204,7 +1207,7 @@ export const typeCheck = (
             if (name in env) {
               // Types.set(withScope(name, env), () => formatType(name, env))
               // If current scope is root then these are user defined types
-              if (isLambda && !isUnknownReturn(env[name][STATS])) {
+              if (isLambda) {
                 const lambdaName = `${PLACEHOLDER}${name}`
                 check(
                   [
@@ -1259,6 +1262,26 @@ export const typeCheck = (
                 }
                 checkReturns()
                 checkArgs()
+                // Check lambda body with defined types
+                const copy = Object.create(env)
+                for (let i = 0; i < env[name][STATS][ARGUMENTS].length; ++i) {
+                  const A = env[lambdaName][STATS][ARGUMENTS][i]
+                  const B = env[name][STATS][ARGUMENTS][i]
+                  copy[A[STATS][SIGNATURE]] = {
+                    [STATS]: {
+                      [SIGNATURE]: A[STATS][SIGNATURE],
+                      [TYPE_PROP]: B[STATS][TYPE_PROP],
+                      [RETURNS]: B[STATS][RETURNS]
+                    }
+                  }
+                }
+                check(
+                  wrapInApplyLambda(exp.at(-1).slice(2)).at(-1),
+                  copy,
+                  scope
+                )
+                // console.log(exp.at(-1).slice(1))
+                // check(exp.at(-1), env, scope)
                 // Types.delete(`; ${rootScopeIndex} ${lambdaName}`)
               }
               typeSet(Types, name, env, exp)

package/src/keywords.js

@@ -110,8 +110,8 @@ export const MUTATORS_SET = new Set([
   'array:set!',
   'push!',
   'array:append!',
-  'array:push!',
-  'var:set!'
+  'array:push!'
+  // 'var:set!'
 ])
 export const GETTERS_SET = new Set([
   KEYWORDS.GET_ARRAY,

package/src/types.js

@@ -91,49 +91,39 @@ export const toTypeNames = (type) => {
       return 'Atom'
     case NUMBER:
       return 'Number'
-    // case ATOM:
-    //   return 'Atom'
     case UNKNOWN:
       return 'Unknown'
     case COLLECTION:
-      // return 'Array'
       return 'Unknown[]'
     case ANY:
       return 'Any'
     default:
-      break
+      return 'Unknown'
   }
 }
+
+export const extractArrayType = (type) => {
+  const arr = [...type].filter((x) => x === '[')
+  return [type.split('[')[0], arr.length]
+}
+const fillArrayType = (n) => Array.from({ length: n - 1 }).fill(COLLECTION)
 export const toTypeCodes = (type) => {
-  switch (type) {
+  const [t, n] = extractArrayType(type)
+  switch (t) {
     case 'Abstraction':
       return [APPLY]
     case 'Boolean':
+      if (n) return [COLLECTION, new SubType(fillArrayType(n).concat(BOOLEAN))]
       return [ATOM, BOOLEAN_SUBTYPE()]
     case 'Atom':
+      if (n) return [COLLECTION, new SubType(fillArrayType(n).concat(ATOM))]
       return [ATOM]
     case 'Number':
+      if (n) return [COLLECTION, new SubType(fillArrayType(n).concat(NUMBER))]
       return [ATOM, NUMBER_SUBTYPE()]
     case 'Unknown':
+      if (n) return [COLLECTION, new SubType(fillArrayType(n))]
       return [UNKNOWN]
-    case 'Unknown[]':
-    case 'Unknowns':
-      // case 'Collection':
-      return [COLLECTION, new SubType([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 'Boolean[][]':
-      return [COLLECTION, new SubType([COLLECTION, BOOLEAN])]
-    case 'Number[][]':
-      return [COLLECTION, new SubType([COLLECTION, NUMBER])]
     case 'Any':
       return [ANY]
     default:

package/src/utils.js

@@ -304,6 +304,10 @@ export const wrapInBlock = (ast) => [
     [[APPLY, KEYWORDS.BLOCK], ...ast]
   ]
 ]
+export const wrapInApplyLambda = (ast) => [
+  [APPLY, KEYWORDS.CALL_FUNCTION],
+  [[APPLY, KEYWORDS.ANONYMOUS_FUNCTION], ...ast]
+]
 export const interpret = (ast, keywords) =>
   ast.reduce((_, x) => evaluate(x, keywords), 0)
 export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)