fez-lisp 1.5.56 → 1.5.58

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.58",
   "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
+              }
             }
           })
         }
@@ -1360,7 +1397,7 @@ export const typeCheck = (ast) => {
                                   fn[STATS][RETURNS][1] !== PREDICATE
                                 ) {
                                   warningStack.add(
-                                    `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (try wrapping it in a (true?) or (false?)) (check #25)`
+                                    `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (check #25)`
                                   )
                                 }
                                 env[name][STATS][TYPE_PROP][0] =
@@ -1402,7 +1439,7 @@ export const typeCheck = (ast) => {
                     env[name][STATS][RETURNS][1] !== PREDICATE
                   ) {
                     warningStack.add(
-                      `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (try wrapping it in a (true?) or (false?)) (check #7)`
+                      `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (check #7)`
                     )
                   } else if (
                     !isPredicate &&
@@ -1550,7 +1587,7 @@ export const typeCheck = (ast) => {
                               fn[STATS][RETURNS][1] !== PREDICATE
                             ) {
                               warningStack.add(
-                                `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (try wrapping it in a (true?) or (false?)) (check #25)`
+                                `${name} ends in (${PREDICATE_SUFFIX}) and is expected to return (Predicate) but it doesn't (check #25)`
                               )
                             }
                             env[name][STATS][TYPE_PROP] = fn[STATS][RETURNS]
@@ -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),