fez-lisp 1.5.94 → 1.5.98

package/src/evaluator.js

@@ -13,10 +13,8 @@ export const evaluate = (exp, env = keywords) => {
   switch (head[TYPE]) {
     case WORD: {
       const word = env[value]
-      if (word == undefined) {
+      if (word == undefined)
         throw new ReferenceError(`Accessing undefined variable ${value}`)
-      }
-
       return word
     }
     case APPLY: {

package/src/types.js

@@ -5,8 +5,10 @@ import {
   DEBUG,
   KEYWORDS,
   PLACEHOLDER,
-  STATIC_TYPES
+  STATIC_TYPES,
+  VALUE
 } from './keywords.js'
+import { stringifyArgs } from './utils.js'
 export const ARG_COUNT = 'argumentsN'
 export const VARIADIC = Infinity
 export const STATS = '__stats__'
@@ -19,7 +21,7 @@ export const UNKNOWN = -1
 export const COLLECTION = 3
 export const PREDICATE = 4
 export const ANY = 5
-
+export const ANONYMOUS_FUNCTION_TYPE_PREFIX = 'lambda::annonymous::'
 export const MAX_ARGUMENT_RETRY = 1
 export const MAX_RETRY_DEFINITION = 10
 export const toTypeNames = (type) => {
@@ -29,7 +31,6 @@ export const toTypeNames = (type) => {
     case ATOM:
       return 'Atom'
     case UNKNOWN:
-      // case ANY:
       return 'Unknown'
     case PREDICATE:
       return 'Predicate'
@@ -44,10 +45,10 @@ export const toTypeNames = (type) => {
 export const SPECIAL_FORM_TYPES = {
   [SCOPE_NAME]: ';',
   // [ORDER]: 0,
-  [toTypeNames(APPLY)]: {
+  [STATIC_TYPES.ABSTRACTION]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
-      [SIGNATURE]: toTypeNames(APPLY),
+      [SIGNATURE]: STATIC_TYPES.ABSTRACTION,
       retried: Infinity,
       [ARG_COUNT]: 1,
       [ARGUMENTS]: [
@@ -66,10 +67,10 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [APPLY]
     }
   },
-  [toTypeNames(ATOM)]: {
+  [STATIC_TYPES.ATOM]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
-      [SIGNATURE]: toTypeNames(ATOM),
+      [SIGNATURE]: STATIC_TYPES.ATOM,
       retried: Infinity,
       [ARG_COUNT]: 1,
       [ARGUMENTS]: [
@@ -88,10 +89,10 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM]
     }
   },
-  [toTypeNames(PREDICATE)]: {
+  [STATIC_TYPES.PREDICATE]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY, PREDICATE],
-      [SIGNATURE]: toTypeNames(PREDICATE),
+      [SIGNATURE]: STATIC_TYPES.PREDICATE,
       retried: Infinity,
       [ARG_COUNT]: 1,
       [ARGUMENTS]: [
@@ -110,10 +111,10 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [ATOM, PREDICATE]
     }
   },
-  [toTypeNames(COLLECTION)]: {
+  [STATIC_TYPES.COLLECTION]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
-      [SIGNATURE]: toTypeNames(COLLECTION),
+      [SIGNATURE]: STATIC_TYPES.COLLECTION,
       retried: Infinity,
       [ARG_COUNT]: 1,
       [ARGUMENTS]: [
@@ -132,10 +133,10 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [COLLECTION]
     }
   },
-  [toTypeNames(UNKNOWN)]: {
+  [STATIC_TYPES.UNKNOWN]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
-      [SIGNATURE]: toTypeNames(UNKNOWN),
+      [SIGNATURE]: STATIC_TYPES.UNKNOWN,
       retried: Infinity,
       [ARG_COUNT]: 1,
       [ARGUMENTS]: [
@@ -154,6 +155,28 @@ export const SPECIAL_FORM_TYPES = {
       [RETURNS]: [UNKNOWN]
     }
   },
+  [STATIC_TYPES.ANY]: {
+    [STATS]: {
+      [TYPE_PROP]: [APPLY],
+      [SIGNATURE]: STATIC_TYPES.ANY,
+      retried: Infinity,
+      [ARG_COUNT]: 1,
+      [ARGUMENTS]: [
+        {
+          [STATS]: {
+            retried: Infinity,
+            [SIGNATURE]: PLACEHOLDER,
+            [TYPE_PROP]: [UNKNOWN],
+            [RETURNS]: [UNKNOWN],
+
+            [ARGUMENTS]: [],
+            [ARG_COUNT]: 0
+          }
+        }
+      ],
+      [RETURNS]: [ANY]
+    }
+  },
   [DEBUG.LOG]: {
     [STATS]: {
       [TYPE_PROP]: [APPLY],
@@ -1167,20 +1190,41 @@ export const formatType = (name, env) => {
       ? `${isAnonymous ? '' : `(let ${name} `}(lambda ${
           stats[ARG_COUNT] === VARIADIC
             ? '... ' + STATIC_TYPES.UNKNOWN
-            : (stats[ARGUMENTS] ?? [])
-                .map(
-                  (x, i) =>
-                    `${
-                      getType(x[STATS]) === APPLY
-                        ? `${formatType(i, stats[ARGUMENTS])}`
-                        : `${toTypeNames(getType(x[STATS]))}`
-                    }`
-                )
-                .join(' ')
+            : stats[ARGUMENTS]?.length
+            ? stats[ARGUMENTS].map(
+                (x, i) =>
+                  `${
+                    getType(x[STATS]) === APPLY
+                      ? `${formatType(i, stats[ARGUMENTS])}`
+                      : `${toTypeNames(getType(x[STATS]))}`
+                  }`
+              ).join(' ') + ' '
+            : ''
           // TODO format returned functions when type support is added
-        } (${KEYWORDS.BLOCK} ${toTypeNames(getReturn(stats))})${
+        }(${KEYWORDS.BLOCK} ${toTypeNames(getReturn(stats))})${
           isAnonymous ? '' : ')'
         })`
       : `(let ${name} ${toTypeNames(getType(stats))})`
     : name
 }
+
+export const validateLambda = (exp, name) => {
+  if (exp.length === 1)
+    throw new TypeError(
+      `Incorrect number of arguments for (${
+        KEYWORDS.ANONYMOUS_FUNCTION
+      }). Expected at least 1 (the lambda body) but got 1 (${stringifyArgs(
+        exp
+      )})`
+    )
+  if (name)
+    for (let i = 0; i < exp.length - 1; ++i)
+      if (exp[i][VALUE] === name)
+        throw new TypeError(
+          `Arguments of (${
+            KEYWORDS.ANONYMOUS_FUNCTION
+          }) Should not have the same name as they were declared (${stringifyArgs(
+            exp
+          )})`
+        )
+}