fez-lisp 1.6.58 → 1.6.60

package/package.json

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

package/src/check.js

@@ -606,7 +606,7 @@ const resolveGetter = ({ rem, prop, name, env }) => {
 
   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 +614,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 +713,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 +784,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 +797,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])]

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:
@@ -1539,3 +1529,12 @@ export const filteredDefinedTypes = (program, lib, libT) => {
 export const definedTypes = (T) => fromSourceToType(T)
 export const withStdDefinedTypes = (ast) =>
   withCtxTypes(definedTypes(filteredDefinedTypes(ast, std, stdT)))
+
+export const extractTypes = (source) => {
+  let types
+  const src = source.replaceAll(/\(the.+\)/g, (match, token) => {
+    types = match
+    return ''
+  })
+  return [src, types]
+}

package/src/utils.js

@@ -21,6 +21,7 @@ import { type, typeCheck, withScope } from './check.js'
 import stdT from '../lib/baked/std-T.js'
 import {
   definedTypes,
+  extractTypes,
   filteredDefinedTypes,
   formatAstTypes,
   withCtxTypes
@@ -380,8 +381,8 @@ export const init = () => {
     console.log('Added directory src in root')
     writeFileSync('./src/main.lisp', '')
     console.log('Added file main.lisp in src')
-    writeFileSync('./src/types.lisp', '')
-    console.log('Added file types.lisp in src')
+    // writeFileSync('./src/types.lisp', '')
+    // console.log('Added file types.lisp in src')
     writeFileSync(
       'index.js',
       `import { compile, enhance, parse, LISP, UTILS } from "fez-lisp";
@@ -406,16 +407,17 @@ export const dev = (source, types) => {
 };
 export const comp = (source) => compile(enhance(parse(source)));
 const file = readFileSync("./src/main.lisp", "utf-8");
+const [src, typ] = UTILS.extractTypes(file);
 switch (process.argv[2]) {
   case "comp":
     writeFileSync(
       "./src/main.js",
-      "var _ = " + comp(file) + "; console.log(_)"
+      "var _ = " + comp(src) + "; console.log(_)"
     );
     break;
   case "dev":
   default:
-    dev(file, readFileSync("./src/types.lisp", "utf-8"));
+    dev(src, typ);
     break;
 }
 `
@@ -424,7 +426,7 @@ switch (process.argv[2]) {
     console.log(
       `Done!
 
-Write code in main.lisp and types (if any) in types.lisp
+Write code in main.lisp
 Run node index.js with the following flags:
 - dev (static type check and run time validations)
 - comp (compile Fez to JavaScript file main.js)
@@ -440,6 +442,7 @@ That's it! You are all set!
 }
 
 export const UTILS = {
+  extractTypes,
   init,
   debug,
   startDebug,