fez-lisp 1.6.25 → 1.6.27

package/index.js

@@ -1,7 +1,7 @@
 import { evaluate } from './src/evaluator.js'
 import { compile } from './src/compiler.js'
-import { parse, fez, UTILS } from './src/utils.js'
+import { parse, fez, UTILS, atst } from './src/utils.js'
 import { LISP, AST } from './src/parser.js'
 import { type } from './src/check.js'
 import { enhance } from './src/enhance.js'
-export { parse, evaluate, compile, type, enhance, fez, LISP, AST, UTILS }
+export { parse, evaluate, compile, type, atst, enhance, fez, LISP, AST, UTILS }

package/package.json

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

package/src/check.js

@@ -16,7 +16,7 @@ import {
   VALUE,
   WORD
 } from './keywords.js'
-import { isLeaf, LISP } from './parser.js'
+import { isLeaf } from './parser.js'
 import {
   SPECIAL_FORM_TYPES,
   toTypeNames,
@@ -91,6 +91,9 @@ export const identity = (name) => [
     [1, 'x']
   ]
 ]
+export const typeSetDefaultFunction = (Types, name, env, exp) =>
+  Types.set(withScope(name, env), () => formatType(name, env))
+
 const returnType = (rest) => {
   const body = rest.at(-1)
   const rem = hasBlock(body) ? body.at(-1) : body
@@ -459,7 +462,7 @@ const getScopeNames = (scope) => {
   }
   return scopeNames.reverse()
 }
-const withScope = (name, scope) => {
+export const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
   return `${chain.join(' ')} ${name}`
 }
@@ -990,7 +993,11 @@ const checkReturnType = ({ exp, stack, name, env, check }) => {
 const stagger = (stack, method, data, fn) => {
   stack[method]({ data, fn })
 }
-export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
+export const typeCheck = (
+  ast,
+  ctx = SPECIAL_FORM_TYPES,
+  typeSet = typeSetDefaultFunction
+) => {
   const Types = new Map()
   const stack = new Brr()
   const rootScopeIndex = 1
@@ -1204,7 +1211,8 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
                 )})`
               )
             if (name in env) {
-              Types.set(withScope(name, env), () => formatType(name, env))
+              typeSet(Types, name, env, exp)
+              // Types.set(withScope(name, env), () => formatType(name, env))
               // If current scope is root then these are user defined types
               if (env[SCOPE_NAME] === rootScopeIndex) break
             }
@@ -1344,7 +1352,8 @@ export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
               }
               check(rightHand, env, scope)
             }
-            Types.set(withScope(name, env), () => formatType(name, env))
+            typeSet(Types, name, env, exp)
+            // Types.set(withScope(name, env), () => formatType(name, env))
             break
           case KEYWORDS.ANONYMOUS_FUNCTION:
             {

package/src/keywords.js

@@ -3,6 +3,7 @@ export const VALUE = 1
 export const APPLY = 0
 export const WORD = 1
 export const ATOM = 2
+export const FLAG = 3
 export const TRUE = 1
 export const FALSE = 0
 export const PLACEHOLDER = '.'

package/src/types.js

@@ -5,11 +5,13 @@ import {
   APPLY,
   ATOM,
   DEBUG,
+  FLAG,
   KEYWORDS,
   PLACEHOLDER,
   STATIC_TYPES,
   TYPE,
-  VALUE
+  VALUE,
+  WORD
 } from './keywords.js'
 import { isLeaf } from './parser.js'
 import { shakedList, stringifyArgs } from './utils.js'
@@ -1368,7 +1370,72 @@ export const formatType = (name, env) => {
       : `(let ${name} ${formatSubType(getTypes(stats))})`
     : name
 }
-
+export const formatInlineType = (name, env) => {
+  const stats = env[name][STATS]
+  return stats
+    ? getType(stats) === APPLY
+      ? `(lambda ${
+          stats[ARG_COUNT] === VARIADIC
+            ? '... '
+            : stats[ARGUMENTS]?.length
+            ? stats[ARGUMENTS].map(
+                (x, i) =>
+                  `${
+                    getType(x[STATS]) === APPLY
+                      ? `${formatType(i, stats[ARGUMENTS])}`
+                      : `${formatSubType(getTypes(x[STATS]))}`
+                  }`
+              ).join(' ') + ' '
+            : ''
+          // TODO format returned functions when type support is added
+        }(${KEYWORDS.BLOCK} ${formatSubType(getReturns(stats))}))`
+      : formatSubType(getTypes(stats))
+    : name
+}
+export const formatAstSubType = (T) => {
+  switch (T[0]) {
+    case COLLECTION:
+      return `${
+        T[1] instanceof Set
+          ? [...T[1]]
+              .map((x) =>
+                x === COLLECTION
+                  ? formatAstSubType([x])
+                  : toTypeNamesAnyToUknown(x)
+              )
+              .join(' ') || toTypeNames(UNKNOWN)
+          : toTypeNames(UNKNOWN)
+      }[]`
+    case ATOM:
+      return `${
+        T[1] instanceof Set
+          ? [...T[1]].map((x) => toTypeNamesAnyToUknown(x)).join(' ')
+          : toTypeNamesAnyToUknown(NUMBER)
+      }`
+    default:
+      return toTypeNamesAnyToUknown(T[0])
+  }
+}
+export const formatAstTypes = (name, env) => {
+  const stats = env[name][STATS]
+  return stats
+    ? getType(stats) === APPLY
+      ? [
+          FLAG,
+          ...(stats[ARG_COUNT] === VARIADIC
+            ? []
+            : stats[ARGUMENTS]?.length
+            ? stats[ARGUMENTS].map((x, i) =>
+                getType(x[STATS]) === APPLY
+                  ? formatAstTypes(i, stats[ARGUMENTS])
+                  : formatAstSubType(getTypes(x[STATS]))
+              )
+            : []),
+          formatAstSubType(getReturns(stats))
+        ]
+      : [FLAG, formatAstSubType(getTypes(stats))]
+    : [FLAG, name]
+}
 export const validateLambda = (exp, name) => {
   if (exp.length === 1)
     throw new TypeError(

package/src/utils.js

@@ -2,6 +2,7 @@ import std from '../lib/baked/std.js'
 import {
   APPLY,
   ATOM,
+  FLAG,
   KEYWORDS,
   STATIC_TYPES,
   TYPE,
@@ -16,9 +17,14 @@ import {
   handleUnbalancedQuotes
 } from './macros.js'
 import { enhance, OPTIMIZATIONS } from './enhance.js'
-import { type } from './check.js'
+import { type, typeCheck, withScope } from './check.js'
 import stdT from '../lib/baked/std-T.js'
-import { definedTypes, withCtxTypes } from './types.js'
+import {
+  definedTypes,
+  filteredDefinedTypes,
+  formatAstTypes,
+  withCtxTypes
+} from './types.js'
 import { compile } from './compiler.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
@@ -520,3 +526,32 @@ export const fez = (ast, c = false) => {
     return [null, err]
   }
 }
+
+export const toTypedAst = (ast, userDefinedTypes) => {
+  try {
+    const types = typeCheck(
+      ast,
+      withCtxTypes(
+        userDefinedTypes
+          ? {
+              ...definedTypes(filteredDefinedTypes(ast, std, stdT)),
+              ...definedTypes(LISP.parse(removeNoCode(userDefinedTypes)))
+            }
+          : definedTypes(filteredDefinedTypes(ast, std, stdT))
+      ),
+      (Types, name, env, exp) => {
+        Types.set(withScope(name, env), () => {
+          if (exp.at(-1)[TYPE] !== FLAG) exp.push(formatAstTypes(name, env))
+          else exp[exp.length - 1] = formatAstTypes(name, env)
+          return ''
+        })
+      }
+    )
+    for (const v of types[1].values()) v()
+    //  types[0][1][1].slice(1)
+    return types
+  } catch (error) {
+    logError(error.message)
+  }
+}
+export const atst = (ast, ctx) => toTypedAst(ast, ctx)[0]