fez-lisp 1.5.86 → 1.5.88

package/package.json

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

package/src/check.js

@@ -1,12 +1,16 @@
 import {
   APPLY,
   ATOM,
+  FALSE,
   KEYWORDS,
   PLACEHOLDER,
-  PREDICATES_SET,
+  PREDICATE_SUFFIX,
+  PREDICATES_INPUT_SET,
+  PREDICATES_OUTPUT_SET,
   SPECIAL_FORMS_SET,
   STATIC_TYPES,
   STATIC_TYPES_SET,
+  TRUE,
   TYPE,
   VALUE,
   WORD
@@ -30,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'],
@@ -54,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(exp)})`
+        )
+      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]
 // }
@@ -164,16 +217,32 @@ export const typeCheck = (ast) => {
                 )
               } else {
                 const name = rest[0][VALUE]
+                //  Predicate name consistency
                 const resolveRetunType = (returns, rem, prop) => {
                   if (returns[TYPE] === ATOM) {
                     // ATOM ASSIGMENT
                     env[name][STATS][prop][0] = ATOM
                     env[name][STATS][RETURNS][0] = ATOM
+                    checkPredicateName(
+                      exp,
+                      [[WORD, name], returns],
+                      warningStack
+                    )
                   } else {
                     switch (returns[VALUE]) {
                       case KEYWORDS.IF:
                         {
                           const re = rem.slice(2)
+                          checkPredicateName(
+                            exp,
+                            [[WORD, name], isLeaf(re[0]) ? re[0] : re[0][0]],
+                            warningStack
+                          )
+                          checkPredicateName(
+                            exp,
+                            [[WORD, name], isLeaf(re[1]) ? re[1] : re[1][0]],
+                            warningStack
+                          )
                           if (re[0][TYPE] === ATOM || re[1][TYPE] === ATOM) {
                             // ATOM ASSIGMENT
                             env[name][STATS][prop][0] = ATOM
@@ -237,12 +306,34 @@ export const typeCheck = (ast) => {
                         }
                         break
                       default:
+                        checkPredicateName(
+                          exp,
+                          [[WORD, name], returns],
+                          warningStack
+                        )
                         if (!env[returns[VALUE]])
                           env[name][STATS][RETURNS] = [UNKNOWN]
                         // env[name][STATS][RETURNS] = APPLY
                         else if (
                           env[returns[VALUE]][STATS][TYPE_PROP][0] === APPLY
                         ) {
+                          if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
+                            const fn = rest.at(-1).at(-1).at(-1)
+                            checkPredicateName(
+                              exp,
+                              [
+                                [WORD, name],
+                                isLeaf(fn)
+                                  ? fn // when apply is a word (let x? (lambda (apply [] array:empty!)))
+                                  : drillReturnType(
+                                      fn,
+                                      (r) => r[VALUE] === KEYWORDS.CALL_FUNCTION
+                                    ) // when apply is an annonymous lambda // (let fn? (lambda x (apply x (lambda x (array:empty! [])))))
+                              ],
+                              warningStack
+                            )
+                          }
+
                           // TODO This seems to be able to be deleted
                           // FOR NOT IT CAN BE
                           // if (returns[VALUE] === KEYWORDS.CALL_FUNCTION) {
@@ -324,6 +415,7 @@ export const typeCheck = (ast) => {
                     check(rightHand, env, exp)
                   }
                 } else {
+                  checkPredicateName(exp, rest, warningStack)
                   const isL = isLeaf(rightHand)
                   if (isL && rightHand[TYPE] === WORD) {
                     // TODO make sure this prevents the assigment all together
@@ -574,10 +666,10 @@ 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
                   // TODO get rof pred type
                   // const PRED_TYPE = args[i][STATS][TYPE_PROP][1]
@@ -585,50 +677,57 @@ export const typeCheck = (ast) => {
                   if (first[TYPE] === APPLY && isSpecial) {
                     if (
                       MAIN_TYPE === ATOM &&
-                      PREDICATES_SET.has(first[VALUE]) &&
-                      !isLeaf(rest[i]) &&
-                      rest[i][0][TYPE] === APPLY &&
-                      rest[i][0][VALUE] === KEYWORDS.CALL_FUNCTION
+                      PREDICATES_INPUT_SET.has(first[VALUE])
                     ) {
-                      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) {
-                          errorStack.add(
-                            `Incorrect type of argument (${i}) for (${
-                              first[VALUE]
-                            }). Expected (${toTypeNames(
-                              MAIN_TYPE
-                            )}) but got an (${toTypeNames(
-                              fn[STATS][RETURNS][0]
-                            )}) (${stringifyArgs(exp)}) (check #26)`
-                          )
-                        }
-                      } else {
-                        const body = rest[i].at(-1).at(-1)
-                        const rem = hasBlock(body) ? body.at(-1) : body
-                        const returns = isLeaf(rem) ? rem : rem[0]
-                        if (returns[TYPE] === ATOM) {
-                          if (MAIN_TYPE !== ATOM) {
+                      // 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] !== ATOM) {
                             errorStack.add(
-                              `Incorrect type of argument ${i} for (${
+                              `Incorrect type of argument (${i}) for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
-                                MAIN_TYPE
-                              )}) but got an (${toTypeNames(
                                 ATOM
-                              )})  (${stringifyArgs(exp)}) (check #27)`
+                              )}) but got an (${toTypeNames(
+                                fn[STATS][RETURNS][0]
+                              )}) (${stringifyArgs(exp)}) (check #26)`
                             )
                           }
-                        } else if (env[returns[VALUE]]) {
-                          if (
-                            MAIN_TYPE !== env[returns[VALUE]][STATS][RETURNS][0]
+                        } else {
+                          const body = rest[i].at(-1).at(-1)
+                          const rem = hasBlock(body) ? body.at(-1) : body
+                          const returns = isLeaf(rem) ? rem : rem[0]
+                          if (returns[TYPE] === ATOM) {
+                            if (MAIN_TYPE !== ATOM) {
+                              errorStack.add(
+                                `Incorrect type of argument ${i} for (${
+                                  first[VALUE]
+                                }). Expected (${toTypeNames(
+                                  MAIN_TYPE
+                                )}) but got an (${toTypeNames(
+                                  ATOM
+                                )})  (${stringifyArgs(exp)}) (check #27)`
+                              )
+                            }
+                          } else if (
+                            env[returns[VALUE]] &&
+                            env[returns[VALUE]][STATS][RETURNS][0] !== ATOM
                           ) {
                             errorStack.add(
                               `Incorrect type of argument ${i} for (${
                                 first[VALUE]
                               }). Expected (${toTypeNames(
-                                MAIN_TYPE
+                                ATOM
                               )}) but got (${toTypeNames(
                                 env[returns[VALUE]][STATS][TYPE_PROP]
                               )})  (${stringifyArgs(exp)}) (check #29)`
@@ -639,89 +738,88 @@ export const typeCheck = (ast) => {
                     }
                     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[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] = 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

@@ -77,10 +77,22 @@ 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_SET = new Set([
+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: '|>',