fez-lisp 1.5.85 → 1.5.87

package/package.json

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

package/src/check.js

@@ -1,11 +1,16 @@
 import {
   APPLY,
   ATOM,
+  FALSE,
   KEYWORDS,
   PLACEHOLDER,
+  PREDICATE_SUFFIX,
+  PREDICATES_INPUT_SET,
+  PREDICATES_OUTPUT_SET,
   SPECIAL_FORMS_SET,
   STATIC_TYPES,
   STATIC_TYPES_SET,
+  TRUE,
   TYPE,
   VALUE,
   WORD
@@ -29,7 +34,12 @@ import {
   VARIABLE_ORDER_INDEX,
   COLLECTION
 } from './types.js'
-import { hasApplyLambdaBlock, hasBlock, stringifyArgs } from './utils.js'
+import {
+  getSuffix,
+  hasApplyLambdaBlock,
+  hasBlock,
+  stringifyArgs
+} from './utils.js'
 
 export const identity = (name) => [
   [0, 'let'],
@@ -53,6 +63,50 @@ const deepLambdaReturn = (rest, condition) => {
   const rem = hasBlock(body) ? body.at(-1) : body
   return condition(rem) ? rem : deepLambdaReturn(rem, condition)
 }
+const checkPredicateName = (exp, rest, warningStack) => {
+  if (getSuffix(rest[0][VALUE]) === PREDICATE_SUFFIX) {
+    const last = rest.at(-1)
+    if (isLeaf(last)) {
+      if (last[TYPE] === ATOM && last[VALUE] !== TRUE && last[VALUE] !== FALSE)
+        warningStack.add(
+          `Assigning predicate (ending in ?) variable (${
+            rest[0][VALUE]
+          }) to an (${
+            STATIC_TYPES.ATOM
+          }) that is not (or ${TRUE} ${FALSE}) (${stringifyArgs(rest)})`
+        )
+      else if (
+        last[TYPE] === WORD &&
+        getSuffix(last[VALUE]) !== PREDICATE_SUFFIX &&
+        !PREDICATES_OUTPUT_SET.has(last[VALUE])
+      )
+        warningStack.add(
+          `Assigning predicate (ending in ?) variable (${
+            rest[0][VALUE]
+          }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
+            exp
+          )})`
+        )
+    } else if (last[0][0] === APPLY) {
+      const application = last[0]
+      switch (application[VALUE]) {
+        default:
+          if (
+            getSuffix(application[VALUE]) !== PREDICATE_SUFFIX &&
+            !PREDICATES_OUTPUT_SET.has(application[VALUE])
+          )
+            warningStack.add(
+              `Assigning predicate (ending in ?) variable (${
+                application[VALUE]
+              }) to another variable which is not a predicate (also ending in ?) (${stringifyArgs(
+                exp
+              )})`
+            )
+          break
+      }
+    }
+  }
+}
 // const assign = (a, b, i) => {
 //   a[i] = b[i]
 // }
@@ -163,6 +217,7 @@ export const typeCheck = (ast) => {
                 )
               } else {
                 const name = rest[0][VALUE]
+                //  Predicate name consistency
                 const resolveRetunType = (returns, rem, prop) => {
                   if (returns[TYPE] === ATOM) {
                     // ATOM ASSIGMENT
@@ -176,6 +231,7 @@ export const typeCheck = (ast) => {
                           if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM) {
                             // ATOM ASSIGMENT
                             env[name][STATS][prop][0] = ATOM
+                            // TODO maybe delete this
                             env[name][STATS][RETURNS][0] = ATOM
                           } else if (
                             !isLeaf(re[0]) &&
@@ -235,55 +291,43 @@ export const typeCheck = (ast) => {
                         }
                         break
                       default:
-                        if (env[returns[VALUE]]) {
-                          if (
-                            env[returns[VALUE]][STATS][TYPE_PROP][0] === APPLY
-                          ) {
-                            if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
-                              if (isLeaf(rest.at(-1).at(-1).at(-1))) {
-                                const fnName = rest.at(-1).at(-1).at(-1)[VALUE]
-                                const fn = env[fnName]
-                                env[name][STATS][TYPE_PROP][0] =
-                                  fn[STATS][RETURNS][0]
-                              } else {
-                                const [returns, rem] = drillReturnType(
-                                  rest.at(-1).at(-1).at(-1),
-                                  (returns) =>
-                                    returns[VALUE] === KEYWORDS.CALL_FUNCTION
-                                )
-                                resolveRetunType(returns, rem, TYPE_PROP)
-                              }
-                            }
-                            // ALWAYS APPLY
-                            // rest.at(-1)[0][TYPE] === APPLY
-                            // Here is upon application to store the result in the variable
-                            if (env[name][STATS][TYPE_PROP][0] === UNKNOWN)
-                              stack.unshift(() => {
-                                env[name][STATS][TYPE_PROP][0] =
-                                  env[returns[VALUE]][STATS][RETURNS][0]
-                                env[name][STATS][TYPE_PROP][1] =
-                                  env[returns[VALUE]][STATS][RETURNS][1]
-                              })
-                            env[name][STATS][RETURNS] =
-                              env[returns[VALUE]][STATS][RETURNS]
-                          } else {
-                            // Enclose function with it's own scope
-                            const args = env[name][STATS][ARGUMENTS] ?? []
-                            const fnScope = args.length
-                              ? Object.create(env)
-                              : env
-                            for (const arg of args)
-                              fnScope[arg[STATS][SIGNATURE]] = arg
-                            // RETURN TYPE OF FUNCTION ASSIGGMENT
-                            fnScope[name][STATS][RETURNS] =
-                              fnScope[returns[VALUE]][STATS][RETURNS]
-                            // assign(env[name][STATS][RETURNS],env[returns[VALUE]][STATS][RETURNS], 0)
-                            fnScope[name][STATS][RETURNS][0] =
-                              fnScope[returns[VALUE]][STATS][TYPE_PROP][0]
-                          }
-                        } else {
+                        if (!env[returns[VALUE]])
                           env[name][STATS][RETURNS] = [UNKNOWN]
-                          // env[name][STATS][RETURNS] = APPLY
+                        // env[name][STATS][RETURNS] = APPLY
+                        else if (
+                          env[returns[VALUE]][STATS][TYPE_PROP][0] === APPLY
+                        ) {
+                          // TODO This seems to be able to be deleted
+                          // FOR NOT IT CAN BE
+                          // if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
+                          //   if (isLeaf(rest.at(-1).at(-1).at(-1))) {
+                          //     const fnName = rest.at(-1).at(-1).at(-1)[VALUE]
+                          //     const fn = env[fnName]
+                          //     env[name][STATS][TYPE_PROP][0] =
+                          //       fn[STATS][RETURNS][0]
+                          //   } else {
+                          //     const [returns, rem] = drillReturnType(
+                          //       rest.at(-1).at(-1).at(-1),
+                          //       (returns) =>
+                          //         returns[VALUE] === KEYWORDS.CALL_FUNCTION
+                          //     )
+                          //     resolveRetunType(returns, rem, TYPE_PROP)
+                          //   }
+                          // }
+
+                          // ALWAYS APPLY
+                          // rest.at(-1)[0][TYPE] === APPLY
+                          // Here is upon application to store the result in the variable
+                          if (env[name][STATS][TYPE_PROP][0] === UNKNOWN)
+                            stack.unshift(() => {
+                              env[name][STATS][TYPE_PROP][0] =
+                                env[returns[VALUE]][STATS][RETURNS][0]
+                              // this seems to be able to be deleted
+                              // env[name][STATS][TYPE_PROP][1] =
+                              //   env[returns[VALUE]][STATS][RETURNS][1]
+                            })
+                          env[name][STATS][RETURNS] =
+                            env[returns[VALUE]][STATS][RETURNS]
                         }
                         break
                     }
@@ -334,8 +378,8 @@ export const typeCheck = (ast) => {
                     check(rightHand, env, exp)
                   }
                 } else {
+                  checkPredicateName(exp, rest, warningStack)
                   const isL = isLeaf(rightHand)
-                  // if (!(name in env)) {
                   if (isL && rightHand[TYPE] === WORD) {
                     // TODO make sure this prevents the assigment all together
                     if (env[rest[1][VALUE]] === undefined) {
@@ -359,7 +403,7 @@ export const typeCheck = (ast) => {
                         [RETURNS]: [ATOM]
                       }
                     }
-                  } else {
+                  } else if (rightHand[0]) {
                     const right = rightHand[0]
                     //DECLARATION
                     env[name] = {
@@ -371,35 +415,27 @@ export const typeCheck = (ast) => {
                         [TYPE_PROP]: [
                           isL
                             ? right[TYPE]
-                            : env[right?.[VALUE]]?.[STATS]?.[RETURNS]?.[0] ??
-                              UNKNOWN
+                            : env[right[VALUE]] == undefined
+                            ? UNKNOWN
+                            : env[right[VALUE]][STATS][RETURNS][0]
                         ],
                         [RETURNS]: [UNKNOWN]
                       }
                     }
-                    if (right && right[VALUE]) {
-                      if (right[VALUE] === KEYWORDS.CALL_FUNCTION) {
-                        if (isLeaf(rightHand.at(-1))) {
-                          const fnName = rightHand.at(-1)[VALUE]
-                          const fn = env[fnName]
-                          // FB assigment
-                          env[name][STATS][TYPE_PROP] = fn[STATS][RETURNS]
-                          env[name][STATS][RETURNS] = fn[STATS][RETURNS]
-                        } else {
-                          const body = rightHand.at(-1).at(-1)
-                          const rem = hasBlock(body) ? body.at(-1) : body
-                          const returns = isLeaf(rem) ? rem : rem[0]
-                          resolveRetunType(returns, rem, TYPE_PROP)
-                        }
-                      } else {
-                        const body = rightHand
+                    if (right[VALUE] === KEYWORDS.CALL_FUNCTION) {
+                      if (!isLeaf(rightHand.at(-1))) {
+                        const body = rightHand.at(-1).at(-1)
                         const rem = hasBlock(body) ? body.at(-1) : body
                         const returns = isLeaf(rem) ? rem : rem[0]
                         resolveRetunType(returns, rem, TYPE_PROP)
                       }
+                    } else {
+                      const body = rightHand
+                      const rem = hasBlock(body) ? body.at(-1) : body
+                      const returns = isLeaf(rem) ? rem : rem[0]
+                      resolveRetunType(returns, rem, TYPE_PROP)
                     }
                   }
-                  // }
                   check(rightHand, env, scope)
                 }
                 Types.set(withScope(name, env), () => formatType(name, env))
@@ -511,7 +547,6 @@ export const typeCheck = (ast) => {
                               ref[STATS][RETURNS] = concequent[STATS][TYPE_PROP]
                           }
                         }
-
                         break
                       default:
                         if (copy[ret[VALUE]])
@@ -594,26 +629,38 @@ export const typeCheck = (ast) => {
                     }
                   }
                 }
-
                 // also type of arg
                 const args = env[first[VALUE]][STATS][ARGUMENTS] ?? []
                 for (let i = 0; i < args.length; ++i) {
+                  const isRestILeaf = isLeaf(rest[i])
                   // type check
-                  const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
+                  // TODO get rof pred type
+                  // const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
                   const MAIN_TYPE = args[i][STATS][TYPE_PROP][0]
-                  if (PRED_TYPE != undefined && !isLeaf(rest[i])) {
-                    const current = rest[i][0]
-                    if (current[TYPE] === APPLY) {
-                      if (current[VALUE] == KEYWORDS.CALL_FUNCTION) {
+                  if (first[TYPE] === APPLY && isSpecial) {
+                    if (
+                      MAIN_TYPE === ATOM &&
+                      PREDICATES_INPUT_SET.has(first[VALUE])
+                    ) {
+                      // if (isRestILeaf && rest[i][TYPE] === ATOM && rest[i][VALUE] !== TRUE && rest[i][TYPE] !== FALSE) throw some rror
+                      //  else if (
+                      //  isRestILeaf && est[i][TYPE] === ATOM && (rest[i][VALUE] === TRUE || rest[i][VALUE] === FALSE)
+                      // )  continue
+                      // else
+                      if (
+                        !isRestILeaf &&
+                        rest[i][0][TYPE] === APPLY &&
+                        rest[i][0][VALUE] === KEYWORDS.CALL_FUNCTION
+                      ) {
                         if (isLeaf(rest[i].at(-1))) {
                           const fnName = rest[i].at(-1)[VALUE]
                           const fn = env[fnName]
-                          if (fn && fn[STATS][RETURNS][0] !== MAIN_TYPE) {
+                          if (fn && fn[STATS][RETURNS][0] !== ATOM) {
                             errorStack.add(
                               `Incorrect type of argument (${i}) for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
-                                MAIN_TYPE
+                                ATOM
                               )}) but got an (${toTypeNames(
                                 fn[STATS][RETURNS][0]
                               )}) (${stringifyArgs(exp)}) (check #26)`
@@ -635,112 +682,107 @@ export const typeCheck = (ast) => {
                                 )})  (${stringifyArgs(exp)}) (check #27)`
                               )
                             }
-                          } else if (env[returns[VALUE]]) {
-                            if (
-                              MAIN_TYPE !==
-                              env[returns[VALUE]][STATS][RETURNS][0]
-                            ) {
-                              errorStack.add(
-                                `Incorrect type of argument ${i} for (${
-                                  first[VALUE]
-                                }). Expected (${toTypeNames(
-                                  MAIN_TYPE
-                                )}) but got (${toTypeNames(
-                                  env[returns[VALUE]][STATS][TYPE_PROP]
-                                )})  (${stringifyArgs(exp)}) (check #29)`
-                              )
-                            }
+                          } else if (
+                            env[returns[VALUE]] &&
+                            env[returns[VALUE]][STATS][RETURNS][0] !== ATOM
+                          ) {
+                            errorStack.add(
+                              `Incorrect type of argument ${i} for (${
+                                first[VALUE]
+                              }). Expected (${toTypeNames(
+                                ATOM
+                              )}) but got (${toTypeNames(
+                                env[returns[VALUE]][STATS][TYPE_PROP]
+                              )})  (${stringifyArgs(exp)}) (check #29)`
+                            )
                           }
                         }
                       }
                     }
-                  }
-                  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 MAIN_TYPE = expectedArgs[i][STATS][TYPE_PROP][0]
-                      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 && !isCast) {
-                          if (env[CAR][STATS][RETURNS][0] !== MAIN_TYPE) {
+                    const EXPECTED_TYPE = expectedArgs[i][STATS][TYPE_PROP][0]
+                    // IF UKNOWN andnot csted -we have nothing much to do
+                    if (EXPECTED_TYPE === UNKNOWN && !isCast) continue
+                    if (!isRestILeaf) {
+                      const CAR = rest[i][0][VALUE]
+                      const isKnown =
+                        env[CAR] && env[CAR][STATS][RETURNS][0] !== UNKNOWN
+                      if (isKnown && !isCast) {
+                        if (env[CAR][STATS][RETURNS][0] !== EXPECTED_TYPE) {
+                          errorStack.add(
+                            `Incorrect type of argument (${i}) for special form (${
+                              first[VALUE]
+                            }). Expected (${toTypeNames(
+                              EXPECTED_TYPE
+                            )}) but got (${toTypeNames(
+                              env[CAR][STATS][RETURNS][0]
+                            )}) (${stringifyArgs(exp)}) (check #1)`
+                          )
+                        }
+                        // never reached because there is only 1 subtype at the moment
+                        // else if (
+                        //   PRED_TYPE &&
+                        //   env[CAR][STATS][RETURNS][1] !== PRED_TYPE
+                        // ) {
+                        // }
+                      }
+                    } else {
+                      switch (rest[i][TYPE]) {
+                        case WORD:
+                          {
+                            const CAR = rest[i][VALUE]
+                            const isKnown =
+                              env[CAR] &&
+                              env[CAR][STATS][TYPE_PROP][0] !== UNKNOWN
+                            if (isKnown && !isCast) {
+                              if (
+                                EXPECTED_TYPE !== env[CAR][STATS][TYPE_PROP][0]
+                              ) {
+                                errorStack.add(
+                                  `Incorrect type of argument (${i}) for special form (${
+                                    first[VALUE]
+                                  }). Expected (${toTypeNames(
+                                    EXPECTED_TYPE
+                                  )}) but got (${toTypeNames(
+                                    env[CAR][STATS][TYPE_PROP][0]
+                                  )}) (${stringifyArgs(exp)}) (check #3)`
+                                )
+                              }
+                            } else if (env[CAR]) {
+                              if (isCast) {
+                                // CAST assigment
+                                env[rest[i][VALUE]][STATS][TYPE_PROP][0] =
+                                  root[first[VALUE]][STATS][RETURNS][0]
+
+                                // root[first[VALUE]][STATS][RETURNS] =
+                                //   root[first[VALUE]][STATS][RETURNS]
+                              } else {
+                                // VALUE assigment
+                                env[CAR][STATS][TYPE_PROP][0] = EXPECTED_TYPE
+                              }
+                            }
+                          }
+                          break
+                        case ATOM: {
+                          if (rest[i][TYPE] !== EXPECTED_TYPE) {
                             errorStack.add(
                               `Incorrect type of argument (${i}) for special form (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
-                                MAIN_TYPE
+                                EXPECTED_TYPE
                               )}) but got (${toTypeNames(
-                                env[CAR][STATS][RETURNS][0]
-                              )}) (${stringifyArgs(exp)}) (check #1)`
+                                rest[i][TYPE]
+                              )}) (${stringifyArgs(exp)}) (check #2)`
                             )
                           }
-                          // never reached because there is only 1 subtype at the moment
-                          // else if (
-                          //   PRED_TYPE &&
-                          //   env[CAR][STATS][RETURNS][1] !== PRED_TYPE
-                          // ) {
-                          // }
-                        }
-                      } else {
-                        switch (rest[i][TYPE]) {
-                          case WORD:
-                            {
-                              const CAR = rest[i][VALUE]
-                              const isKnown =
-                                env[CAR] &&
-                                env[CAR][STATS][TYPE_PROP][0] !== UNKNOWN
-                              if (isKnown && !isCast) {
-                                if (
-                                  MAIN_TYPE !== env[CAR][STATS][TYPE_PROP][0]
-                                ) {
-                                  errorStack.add(
-                                    `Incorrect type of argument (${i}) for special form (${
-                                      first[VALUE]
-                                    }). Expected (${toTypeNames(
-                                      MAIN_TYPE
-                                    )}) but got (${toTypeNames(
-                                      env[CAR][STATS][TYPE_PROP][0]
-                                    )}) (${stringifyArgs(exp)}) (check #3)`
-                                  )
-                                }
-                              } else if (env[rest[i][VALUE]]) {
-                                if (isCast) {
-                                  // CAST assigment
-                                  env[rest[i][VALUE]][STATS][TYPE_PROP] =
-                                    root[first[VALUE]][STATS][RETURNS]
-                                  root[first[VALUE]][STATS][RETURNS] =
-                                    root[first[VALUE]][STATS][RETURNS]
-                                } else {
-                                  // VALUE assigment
-                                  env[rest[i][VALUE]][STATS][TYPE_PROP][0] =
-                                    MAIN_TYPE
-                                }
-                              }
-                            }
-                            break
-                          case ATOM: {
-                            if (rest[i][TYPE] !== MAIN_TYPE) {
-                              errorStack.add(
-                                `Incorrect type of argument (${i}) for special form (${
-                                  first[VALUE]
-                                }). Expected (${toTypeNames(
-                                  MAIN_TYPE
-                                )}) but got (${toTypeNames(
-                                  rest[i][TYPE]
-                                )}) (${stringifyArgs(exp)}) (check #2)`
-                              )
-                            }
-                            break
-                          }
+                          break
                         }
                       }
                     }
                   }
                   // type checking
-                  else if (isLeaf(rest[i])) {
+                  else if (isRestILeaf) {
                     const T =
                       rest[i][TYPE] === WORD && env[rest[i][VALUE]]
                         ? env[rest[i][VALUE]][STATS][TYPE_PROP][0]

package/src/keywords.js

@@ -15,7 +15,6 @@ export const STATIC_TYPES = {
   COLLECTION: 'Collection',
   PREDICATE: 'Predicate'
 }
-export const STATIC_TYPES_SET = new Set(Object.values(STATIC_TYPES))
 export const KEYWORDS = {
   LOOP: 'loop',
   CREATE_ARRAY: 'array',
@@ -77,3 +76,23 @@ export const DEBUG = {
 export const SPECIAL_FORMS_SET = new Set(
   Object.values(KEYWORDS).concat(Object.values(STATIC_TYPES))
 )
+export const STATIC_TYPES_SET = new Set(Object.values(STATIC_TYPES))
+export const PREDICATES_INPUT_SET = new Set([
+  KEYWORDS.IF,
+  KEYWORDS.AND,
+  KEYWORDS.OR,
+  KEYWORDS.NOT,
+  KEYWORDS.LOOP
+])
+export const PREDICATES_OUTPUT_SET = new Set([
+  KEYWORDS.AND,
+  KEYWORDS.OR,
+  KEYWORDS.NOT,
+  KEYWORDS.EQUAL,
+  KEYWORDS.GREATHER_THAN,
+  KEYWORDS.LESS_THAN,
+  KEYWORDS.GREATHER_THAN_OR_EQUAL,
+  KEYWORDS.LESS_THAN_OR_EQUAL,
+  KEYWORDS.IS_ATOM,
+  KEYWORDS.IS_LAMBDA
+])

package/src/macros.js

@@ -10,14 +10,12 @@ import {
   FALSE,
   KEYWORDS,
   PLACEHOLDER,
-  PREDICATE_SUFFIX,
-  STATIC_TYPES,
   TRUE,
   TYPE,
   VALUE,
   WORD
 } from './keywords.js'
-import { getSuffix, hasBlock, stringifyArgs } from './utils.js'
+import { hasBlock, stringifyArgs } from './utils.js'
 export const SUGGAR = {
   // Syntactic suggars
   PIPE: '|>',