fez-lisp 1.5.56 → 1.5.57

package/package.json

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

package/src/check.js

@@ -8,6 +8,7 @@ import {
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   SPECIAL_FORMS_SET,
+  STATIC_TYPES,
   STATIC_TYPES_SET,
   TRUE,
   TYPE,
@@ -80,12 +81,20 @@ const formatType = (name, env) => {
       ? `${name} (${(stats[ARGUMENTS] ?? [])
           .map(
             (x) =>
-              `${x[STATS][SIGNATURE]} ${toTypeNames(x[STATS][TYPE_PROP][0])}`
+              `${x[STATS][SIGNATURE]} ${x[STATS][TYPE_PROP].map(
+                toTypeNames
+              ).join(' ')}${
+                x[STATS][TYPE_PROP][0] === APPLY
+                  ? ` ${toTypeNames(
+                      x[STATS][RETURNS][1] ?? x[STATS][RETURNS][0]
+                    )}`
+                  : ''
+              }`
           )
           .join(' ')}) -> ${toTypeNames(
           stats[RETURNS][1] ?? stats[RETURNS][0]
         )}`
-      : `${name} ${toTypeNames(stats[TYPE_PROP][0])}`
+      : `${name} ${stats[TYPE_PROP].map(toTypeNames).join(' ')}`
     : name
 }
 const formatTypes = (env) => {
@@ -108,7 +117,9 @@ const getScopeNames = (scope) => {
 }
 const withScope = (name, scope) => {
   const chain = getScopeNames(scope)
-  return `${chain.join(' ')} ${name}`
+  return `${chain
+    .map((x) => (Number.isInteger(+x) ? '~' : x))
+    .join(' ')} ${name}`
 }
 export const typeCheck = (ast) => {
   const root = {
@@ -1245,6 +1256,32 @@ export const typeCheck = (ast) => {
               errorStack.add(
                 `Trying to access undefined variable ${first[VALUE]} (check #11)`
               )
+            } else {
+              const T = env[first[VALUE]][STATS]
+              const isKnown = T[TYPE_PROP][0] !== UNKNOWN
+              switch (first[VALUE]) {
+                case 'xs':
+                  if (isKnown && T[TYPE_PROP][0] !== COLLECTION) {
+                    warningStack.add(
+                      `A variable named xs must be of type (${
+                        STATIC_TYPES.COLLECTION
+                      }) but got type (${toTypeNames(
+                        T[TYPE_PROP][0]
+                      )}) (check #32)`
+                    )
+                  } else T[TYPE_PROP] = [COLLECTION]
+                  break
+                default:
+                  {
+                    const isPredicate =
+                      getSuffix(first[VALUE]) === PREDICATE_SUFFIX
+                    if (isPredicate) {
+                      if (isKnown) T[TYPE_PROP][1] = PREDICATE
+                      T[RETURNS] = [ATOM, PREDICATE]
+                    }
+                  }
+                  break
+              }
             }
           })
         }
@@ -1743,6 +1780,7 @@ export const typeCheck = (ast) => {
                         if (isLeaf(rest[i])) {
                           if (rest[i][TYPE] === WORD) {
                             if (
+                              !isSpecial &&
                               env[rest[i][VALUE]] &&
                               PRED_TYPE !==
                                 env[rest[i][VALUE]][STATS][RETURNS][1]

package/src/compiler.js

@@ -264,7 +264,7 @@ const comp = (tree, Drill) => {
         return `__error(${compile(tail[0], Drill)})`
       }
 
-      case STATIC_TYPES.APPLICATION:
+      case STATIC_TYPES.ABSTRACTION:
       case STATIC_TYPES.COLLECTION:
       case STATIC_TYPES.UNKNOWN:
       case STATIC_TYPES.ATOM:

package/src/interpreter.js

@@ -833,7 +833,7 @@ export const keywords = {
     throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
   },
 
-  [STATIC_TYPES.APPLICATION]: (args, env) => evaluate(args[0], env),
+  [STATIC_TYPES.ABSTRACTION]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.ATOM]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.COLLECTION]: (args, env) => evaluate(args[0], env),
   [STATIC_TYPES.PREDICATE]: (args, env) => evaluate(args[0], env),

package/src/keywords.js

@@ -9,7 +9,7 @@ export const PLACEHOLDER = '.'
 export const MUTATION_SUFFIX = '!'
 export const PREDICATE_SUFFIX = '?'
 export const STATIC_TYPES = {
-  APPLICATION: 'Abstraction',
+  ABSTRACTION: 'Abstraction',
   UNKNOWN: 'Unknown',
   ATOM: 'Atom',
   COLLECTION: 'Collection',

package/src/utils.js

@@ -321,7 +321,7 @@ export const addTypeIdentities = (ast) => {
   const temp = block.shift()
   block.unshift(
     temp,
-    identity(STATIC_TYPES.APPLICATION),
+    identity(STATIC_TYPES.ABSTRACTION),
     identity(STATIC_TYPES.ATOM),
     identity(STATIC_TYPES.COLLECTION),
     identity(STATIC_TYPES.PREDICATE),