fez-lisp 1.5.53 → 1.5.56

package/package.json

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

package/src/check.js

@@ -8,6 +8,7 @@ import {
   PLACEHOLDER,
   PREDICATE_SUFFIX,
   SPECIAL_FORMS_SET,
+  STATIC_TYPES_SET,
   TRUE,
   TYPE,
   VALUE,
@@ -34,11 +35,10 @@ const PREDICATE = 3
 const COLLECTION = 4
 const RETRY_COUNT = 1
 const DEFINITON_RETRY_COUNT = 1
-const SUB = 2
 const toTypeNames = (type) => {
   switch (type) {
     case APPLY:
-      return 'Application'
+      return 'Abstraction'
     case ATOM:
       return 'Atom'
     case UNKNOWN:
@@ -1234,7 +1234,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]) {
@@ -1593,7 +1593,7 @@ export const typeCheck = (ast) => {
                   // }
                   check(rest.at(-1), env, scope)
                 }
-                Types.set(withScope(name, env), formatType(name, env))
+                Types.set(withScope(name, env), () => formatType(name, env))
               }
             }
             break
@@ -1897,18 +1897,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 (${
@@ -1943,7 +1943,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]
@@ -1959,7 +1959,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 (${
@@ -1972,8 +1974,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/keywords.js

@@ -9,12 +9,13 @@ export const PLACEHOLDER = '.'
 export const MUTATION_SUFFIX = '!'
 export const PREDICATE_SUFFIX = '?'
 export const STATIC_TYPES = {
-  APPLICATION: 'Application',
+  APPLICATION: '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,9 @@ export const DEBUG = {
   SIGNATURE: '?',
   LIST_THEMES: 'theme?',
   SET_THEME: 'theme!',
-  TYPE_SIGNATURE: 'type?'
+  TYPE_SIGNATURE: 't?'
 }
 
-export const SPECIAL_FORMS_SET = new Set(Object.values(KEYWORDS))
+export const SPECIAL_FORMS_SET = new Set(
+  Object.values(KEYWORDS).concat(Object.values(STATIC_TYPES))
+)

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