fez-lisp 1.5.54 → 1.5.57

package/package.json

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

package/src/check.js

@@ -8,6 +8,8 @@ import {
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   SPECIAL_FORMS_SET,
+  STATIC_TYPES,
+  STATIC_TYPES_SET,
   TRUE,
   TYPE,
   VALUE,
@@ -37,7 +39,7 @@ const DEFINITON_RETRY_COUNT = 1
 const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
-      return 'Application'
+      return 'Abstraction'
     case ATOM:
       return 'Atom'
     case UNKNOWN:
@@ -79,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) => {
@@ -107,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 = {
@@ -122,8 +134,8 @@ export const typeCheck = (ast) => {
             [STATS]: {
               retried: RETRY_COUNT,
               [SIGNATURE]: PLACEHOLDER,
-              [TYPE_PROP]: [APPLY],
-              [RETURNS]: [APPLY],
+              [TYPE_PROP]: [UNKNOWN],
+              [RETURNS]: [UNKNOWN],
               [ARGS_COUNT]: [],
               [ARGUMENTS]: [],
               [ARGS_COUNT]: 0
@@ -144,8 +156,8 @@ export const typeCheck = (ast) => {
             [STATS]: {
               retried: RETRY_COUNT,
               [SIGNATURE]: PLACEHOLDER,
-              [TYPE_PROP]: [ATOM],
-              [RETURNS]: [ATOM],
+              [TYPE_PROP]: [UNKNOWN],
+              [RETURNS]: [UNKNOWN],
               [ARGS_COUNT]: [],
               [ARGUMENTS]: [],
               [ARGS_COUNT]: 0
@@ -166,8 +178,8 @@ export const typeCheck = (ast) => {
             [STATS]: {
               retried: RETRY_COUNT,
               [SIGNATURE]: PLACEHOLDER,
-              [TYPE_PROP]: [APPLY, PREDICATE],
-              [RETURNS]: [APPLY, PREDICATE],
+              [TYPE_PROP]: [UNKNOWN],
+              [RETURNS]: [UNKNOWN],
               [ARGS_COUNT]: [],
               [ARGUMENTS]: [],
               [ARGS_COUNT]: 0
@@ -188,8 +200,8 @@ export const typeCheck = (ast) => {
             [STATS]: {
               retried: RETRY_COUNT,
               [SIGNATURE]: PLACEHOLDER,
-              [TYPE_PROP]: [COLLECTION],
-              [RETURNS]: [COLLECTION],
+              [TYPE_PROP]: [UNKNOWN],
+              [RETURNS]: [UNKNOWN],
               [ARGS_COUNT]: [],
               [ARGUMENTS]: [],
               [ARGS_COUNT]: 0
@@ -1233,7 +1245,7 @@ export const typeCheck = (ast) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first === undefined) {
       throw new TypeError(
-        `(lambda) invocation with missing (Application) name () Provide an (Application) name as the (1) argument.`
+        `(lambda) invocation with missing (Abstraction) name () Provide an (Abstraction) name as the (1) argument.`
       )
     }
     switch (first[TYPE]) {
@@ -1244,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
+              }
             }
           })
         }
@@ -1742,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]
@@ -1896,17 +1935,18 @@ export const typeCheck = (ast) => {
                       }
 
                       if (first[TYPE] === APPLY && isSpecial) {
+                        const isCast = STATIC_TYPES_SET.has(first[VALUE])
                         const expectedArgs = env[first[VALUE]][STATS][ARGUMENTS]
                         for (let i = 0; i < rest.length; ++i) {
                           const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
                           const MAIN_TYPE = expectedArgs[i][STATS][TYPE_PROP][0]
-                          if (MAIN_TYPE === UNKNOWN) continue
+                          if (MAIN_TYPE === UNKNOWN && !isCast) continue
                           if (!isLeaf(rest[i])) {
                             const CAR = rest[i][0][VALUE]
                             const isKnown =
                               env[CAR] &&
                               env[CAR][STATS][RETURNS][0] !== UNKNOWN
-                            if (isKnown) {
+                            if (isKnown && !isCast) {
                               if (env[CAR][STATS][RETURNS][0] !== MAIN_TYPE) {
                                 errorStack.add(
                                   `Incorrect type of argument (${i}) for special form (${
@@ -1941,7 +1981,7 @@ export const typeCheck = (ast) => {
                                   const isKnown =
                                     env[CAR] &&
                                     env[CAR][STATS][TYPE_PROP][0] !== UNKNOWN
-                                  if (isKnown) {
+                                  if (isKnown && !isCast) {
                                     if (
                                       MAIN_TYPE !==
                                       env[CAR][STATS][TYPE_PROP][0]
@@ -1957,7 +1997,9 @@ export const typeCheck = (ast) => {
                                       )
                                     } else if (
                                       PRED_TYPE &&
-                                      env[CAR][STATS][RETURNS][1] !== PRED_TYPE
+                                      env[CAR][STATS][RETURNS][1] !==
+                                        PRED_TYPE &&
+                                      !isCast
                                     )
                                       errorStack.add(
                                         `Incorrect type of argument (${i}) for special form (${
@@ -1970,8 +2012,15 @@ export const typeCheck = (ast) => {
                                         )}) (${stringifyArgs(exp)}) (check #6)`
                                       )
                                   } else if (env[rest[i][VALUE]]) {
-                                    env[rest[i][VALUE]][STATS][TYPE_PROP][0] =
-                                      MAIN_TYPE
+                                    if (isCast) {
+                                      env[rest[i][VALUE]][STATS][TYPE_PROP] =
+                                        root[first[VALUE]][STATS][RETURNS]
+                                      root[first[VALUE]][STATS][RETURNS] =
+                                        root[first[VALUE]][STATS][RETURNS]
+                                    } else {
+                                      env[rest[i][VALUE]][STATS][TYPE_PROP][0] =
+                                        MAIN_TYPE
+                                    }
                                   }
                                 }
                                 break

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,12 +9,13 @@ export const PLACEHOLDER = '.'
 export const MUTATION_SUFFIX = '!'
 export const PREDICATE_SUFFIX = '?'
 export const STATIC_TYPES = {
-  APPLICATION: 'Application',
+  ABSTRACTION: 'Abstraction',
   UNKNOWN: 'Unknown',
   ATOM: 'Atom',
   COLLECTION: 'Collection',
   PREDICATE: 'Predicate'
 }
+export const STATIC_TYPES_SET = new Set(Object.values(STATIC_TYPES))
 export const KEYWORDS = {
   LOOP: 'loop',
   CREATE_ARRAY: 'array',
@@ -70,7 +71,7 @@ export const DEBUG = {
   SIGNATURE: '?',
   LIST_THEMES: 'theme?',
   SET_THEME: 'theme!',
-  TYPE_SIGNATURE: 'type?'
+  TYPE_SIGNATURE: 't?'
 }
 
 export const SPECIAL_FORMS_SET = new Set(

package/src/macros.js

@@ -863,6 +863,11 @@ const iron = (scope) => {
     for (let i = 0; i < copy.length; ++i) scope[i] = copy[i]
   }
 }
+export const seeIfProgramIsInvalid = (source) => {
+  if (source.includes('()') || source.includes(',') || source.includes(';'))
+    throw new SyntaxError(`Failed to parse due to invalid lisp programm near`)
+  return source
+}
 export const replaceQuotes = (source) =>
   source
     .replaceAll(/\[/g, `(${KEYWORDS.CREATE_ARRAY} `)

package/src/parser.js

@@ -11,10 +11,6 @@ export const LISP = {
       const cursor = source[i]
       if (cursor === '(') {
         const temp = []
-        if (head == undefined)
-          throw new SyntaxError(
-            `Failed to parse due to invalid lisp programm near ${acc}`
-          )
         head.push(temp)
         stack.push(head)
         head = temp

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),