fez-lisp 1.6.60 → 1.6.62

package/package.json

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

package/src/check.js

@@ -47,7 +47,7 @@ import {
   NUMBER_SUBTYPE,
   UNKNOWN_SUBTYPE,
   SubType,
-  GET_ARRAY_INFERENCE
+  GET_ARRAY_INFERENCE_SET
 } from './types.js'
 import {
   Brr,
@@ -56,7 +56,9 @@ import {
   hasBlock,
   log,
   logExp,
-  stringifyArgs
+  stringifyArgs,
+  wrapInApplyLambda,
+  wrapInBlock
 } from './utils.js'
 
 export const identity = (name) => [
@@ -603,7 +605,6 @@ 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 (hasSubReturn(env[array[VALUE]][STATS])) {
@@ -851,7 +852,7 @@ const resolveReturnType = ({
         break
       default:
         {
-          if (returns[VALUE] === GET_ARRAY_INFERENCE)
+          if (GET_ARRAY_INFERENCE_SET.has(returns[VALUE]))
             resolveGetter({ rem, prop, name, env })
           checkPredicateNameDeep(name, exp, exp.slice(1), returns)
           // TODO: DRY
@@ -1206,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(
                   [
@@ -1261,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/types.js

@@ -36,7 +36,12 @@ export const IS_ARGUMENT = 'is_arg'
 export const NIL = 'nil'
 export const TRUE_WORD = 'true'
 export const FALSE_WORD = 'false'
-export const GET_ARRAY_INFERENCE = 'array:get'
+export const GET_ARRAY_INFERENCE_SET = new Set([
+  'array:get',
+  'array:at'
+  // 'array:first',
+  // 'array:last'
+])
 export class SubType {
   constructor(args) {
     this.types = []

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)