fez-lisp 1.5.158 → 1.5.159

package/package.json

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

package/src/check.js

@@ -841,7 +841,7 @@ const resolveReturnType = ({
                               // This is insitialisation of identity or any other
                               // function that returns it's argument
                               // Redifine the variable but since it's an error doing that
-                              // Delete it
+                              // Delete it first
                               delete env[name]
                               check(
                                 [
@@ -920,7 +920,7 @@ const checkReturnType = ({ exp, stack, name, env, check }) => {
 const stagger = (stack, method, data, fn) => {
   stack[method]({ data, fn })
 }
-export const typeCheck = (ast) => {
+export const typeCheck = (ast, ctx = SPECIAL_FORM_TYPES) => {
   const Types = new Map()
   const stack = new Brr()
   let scopeIndex = 0
@@ -1124,6 +1124,7 @@ export const typeCheck = (ast) => {
                   exp
                 )})`
               )
+            // TODO check leT define types
             const name = rest[0][VALUE]
             if (env.hasOwnProperty(name))
               throw new ReferenceError(
@@ -1131,6 +1132,10 @@ export const typeCheck = (ast) => {
                   exp
                 )})`
               )
+            if (name in env) {
+              Types.set(withScope(name, env), () => formatType(name, env))
+              break
+            }
             //  Predicate name consistency
             const rightHand = rest.at(-1)
             if (
@@ -1657,8 +1662,8 @@ export const typeCheck = (ast) => {
       }
     }
   }
-  check(ast, SPECIAL_FORM_TYPES, ast)
+  check(ast, ctx, ast)
   while (stack.length) stack.cut().fn()
   return [ast, Types]
 }
-export const type = (ast) => typeCheck(ast)[0]
+export const type = (ast, ctx) => typeCheck(ast, ctx)[0]

package/src/types.js

@@ -6,9 +6,11 @@ import {
   KEYWORDS,
   PLACEHOLDER,
   STATIC_TYPES,
+  TYPE,
   VALUE
 } from './keywords.js'
-import { stringifyArgs } from './utils.js'
+import { isLeaf } from './parser.js'
+import { shakedList, stringifyArgs } from './utils.js'
 export const ARG_COUNT = 'argumentsN'
 export const VARIADIC = Infinity
 export const STATS = '__stats__'
@@ -61,6 +63,30 @@ export const toTypeNames = (type) => {
       break
   }
 }
+export const toTypeCodes = (type) => {
+  switch (type) {
+    case 'Abstraction':
+      return [APPLY]
+    case 'Boolean':
+      return [ATOM, BOOLEAN_SUBTYPE()]
+    case 'Atom':
+      return [ATOM]
+    case 'Number':
+      return [ATOM, NUMBER_SUBTYPE()]
+    case 'Unknown':
+      return [UNKNOWN]
+    case 'Unknowns':
+      return [COLLECTION]
+    case 'Numbers':
+      return [COLLECTION, NUMBER_SUBTYPE()]
+    case 'Booleans':
+      return [COLLECTION, BOOLEAN_SUBTYPE()]
+    case 'Any':
+      return [ANY]
+    default:
+      break
+  }
+}
 export const toTypeNamesAnyToUknown = (type) => {
   switch (type) {
     case ANY:
@@ -1330,3 +1356,62 @@ export const validateLambda = (exp, name) => {
           )})`
         )
 }
+
+export const lambdaType = (t) => [t.slice(1, -1), t.at(-1)[1]]
+export const toArgType = (A, i) => {
+  const out = []
+  const arg = isLeaf(A) ? A : A[0]
+  if (arg[TYPE] === APPLY) {
+    const [args, returns] = lambdaType(A)
+    out.push({
+      [STATS]: {
+        argIndex: i,
+        retried: Infinity,
+        [IS_ARGUMENT]: true,
+        [SIGNATURE]: PLACEHOLDER,
+        [TYPE_PROP]: [APPLY],
+        [RETURNS]: toTypeCodes(returns[VALUE]),
+        [ARGUMENTS]: args.map(toArgType).flat(1),
+        [ARG_COUNT]: args.length
+      }
+    })
+  } else {
+    out.push({
+      [STATS]: {
+        argIndex: i,
+        retried: Infinity,
+        [IS_ARGUMENT]: true,
+        [SIGNATURE]: PLACEHOLDER,
+        [TYPE_PROP]: toTypeCodes(arg[VALUE]),
+        [RETURNS]: toTypeCodes(arg[VALUE]),
+        [ARGUMENTS]: [],
+        [ARG_COUNT]: 0
+      }
+    })
+  }
+  return out
+}
+export const fromSourceToType = (T) => {
+  const out = {}
+  for (const t of T) {
+    const name = t[1][VALUE]
+    const [args, returns] = lambdaType(t[2])
+    out[name] = {
+      [STATS]: {
+        retried: Infinity,
+        [TYPE_PROP]: [APPLY],
+        [SIGNATURE]: name,
+        [ARG_COUNT]: args.length,
+        [ARGUMENTS]: args.map(toArgType).flat(1),
+        [RETURNS]: toTypeCodes(returns[VALUE])
+      }
+    }
+  }
+  return out
+}
+export const withCtxTypes = (T) => ({ ...SPECIAL_FORM_TYPES, ...T })
+export const filteredDefinedTypes = (program, lib, libT) => {
+  const deps = new Set(shakedList(program, lib))
+  return libT.filter((x) => deps.has(x[1][1]))
+}
+export const definedTypes = (T) => fromSourceToType(T)