fez-lisp 1.2.50 → 1.2.53

package/package.json

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

package/src/compiler.js

@@ -313,16 +313,6 @@ const compile = (tree, Drill) => {
           Drill
         )}:${Arguments.length === 3 ? compile(Arguments[2], Drill) : 0});`
       }
-      case KEYWORDS.CONDITION: {
-        let out = '('
-        for (let i = 0; i < Arguments.length; i += 2)
-          out += `${compile(Arguments[i], Drill)}?${compile(
-            Arguments[i + 1],
-            Drill
-          )}:`
-        out += '0);'
-        return out
-      }
       case KEYWORDS.THROW: {
         Drill.Helpers.add('__error')
         return `__error(${compile(Arguments[0], Drill)})`

package/src/interpreter.js

@@ -171,37 +171,6 @@ export const keywords = {
       ? evaluate(args[2], env)
       : 0
   },
-  [KEYWORDS.CONDITION]: (args, env) => {
-    if (args.length < 2)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.CONDITION
-        }), expected (> 2 required) but got ${args.length} (${
-          KEYWORDS.CONDITION
-        } ${stringifyArgs(args)})`
-      )
-    if (args.length % 2 !== 0)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.CONDITION
-        }), expected even number of arguments but got ${args.length} (${
-          KEYWORDS.CONDITION
-        } ${stringifyArgs(args)})`
-      )
-    for (let i = 0; i < args.length; i += 2) {
-      const condition = evaluate(args[i], env)
-      if (condition !== FALSE && condition !== TRUE)
-        throw new TypeError(
-          `Condition of (${
-            KEYWORDS.CONDITION
-          }) must be ${TRUE} or ${FALSE} but got (${
-            KEYWORDS.CONDITION
-          } ${stringifyArgs(args)})`
-        )
-      if (condition) return evaluate(args[i + 1], env)
-    }
-    return 0
-  },
   [KEYWORDS.ARRAY_TYPE]: (args, env) => {
     return args.length ? args.map((x) => evaluate(x, env)) : []
   },

package/src/keywords.js

@@ -15,7 +15,7 @@ export const SUGGAR = {
   LIST_TYPE: 'list',
   POWER: '**',
   INTEGER_DEVISION: '//',
-
+  CONDITION: 'cond',
   RECURSION: 'recursive',
   CACHE: 'memoized'
 }
@@ -42,7 +42,6 @@ export const KEYWORDS = {
   BLOCK: 'do',
   ANONYMOUS_FUNCTION: 'lambda',
   IF: 'if',
-  CONDITION: 'cond',
   NOT: 'not',
   EQUAL: '=',
   LESS_THAN: '<',

package/src/utils.js

@@ -1,6 +1,16 @@
 import std from '../lib/baked/std.js'
 import { comp } from './compiler.js'
-import { APPLY, ATOM, KEYWORDS, SUGGAR, TYPE, VALUE, WORD } from './keywords.js'
+import {
+  APPLY,
+  ATOM,
+  FALSE,
+  KEYWORDS,
+  SUGGAR,
+  TRUE,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
 import { evaluate, run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 export const logError = (error) =>
@@ -385,8 +395,8 @@ export const deSuggar = (ast) => {
                       prev[TYPE] === APPLY &&
                       prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
                   ) {
-                    exp[0][1] = KEYWORDS.CALL_FUNCTION
-                    exp[0][0] = APPLY
+                    exp[0][VALUE] = KEYWORDS.CALL_FUNCTION
+                    exp[0][TYPE] = APPLY
                     exp.length = 1
                     exp[1] = [
                       [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
@@ -437,15 +447,46 @@ export const deSuggar = (ast) => {
                   deSuggar(exp)
                 }
                 break
+              case SUGGAR.CONDITION:
+                {
+                  if (rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.CONDITION
+                      }), expected (> 2 required) but got ${rest.length} (${
+                        SUGGAR.CONDITION
+                      } ${stringifyArgs(rest)})`
+                    )
+                  if (rest.length % 2 !== 0)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.CONDITION
+                      }), expected even number of arguments but got ${
+                        rest.length
+                      } (${SUGGAR.CONDITION} ${stringifyArgs(rest)})`
+                    )
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 2) {
+                    if (i === rest.length - 2) {
+                      temp.push([APPLY, KEYWORDS.IF], rest[i], rest.at(-1))
+                    } else {
+                      temp.push([APPLY, KEYWORDS.IF], rest[i], rest[i + 1], [])
+                      temp = temp.at(-1)
+                    }
+                  }
+                  deSuggar(exp)
+                }
+                break
               case SUGGAR.LIST_TYPE:
                 {
                   exp.length = 0
                   let temp = exp
                   for (const item of rest) {
-                    temp.push([0, KEYWORDS.ARRAY_TYPE], item, [])
+                    temp.push([APPLY, KEYWORDS.ARRAY_TYPE], item, [])
                     temp = temp.at(-1)
                   }
-                  temp.push([0, 'array'])
+                  temp.push([APPLY, KEYWORDS.ARRAY_TYPE])
                   deSuggar(exp)
                 }
                 break
@@ -465,7 +506,7 @@ export const deSuggar = (ast) => {
                     exp.length = 1
                     exp[0] = [APPLY, KEYWORDS.BITWISE_OR]
                     exp.push([[APPLY, KEYWORDS.DIVISION], ...rest])
-                    exp.push([ATOM, 0])
+                    exp.push([ATOM, FALSE])
                   }
                 }
                 break
@@ -479,23 +520,28 @@ export const deSuggar = (ast) => {
                         SUGGAR.POWER
                       } ${stringifyArgs(rest)})`
                     )
-                  if (
-                    (exp[2][TYPE] === ATOM || exp[2][TYPE] === WORD) &&
-                    (exp[1][TYPE] === WORD || exp[1][TYPE] === ATOM)
-                  ) {
+                  const isExponentAtom = exp[1][TYPE] === ATOM
+                  const isPowerAtom = exp[2][TYPE] === ATOM
+                  const isExponentWord = exp[1][TYPE] === WORD
+                  if ((isExponentWord || isExponentAtom) && isPowerAtom) {
                     exp[0][VALUE] = KEYWORDS.MULTIPLICATION
                     const exponent = exp[1]
                     const power = exp[2][VALUE]
                     exp.length = 1
-                    const right = Array.from({ length: power })
-                      .fill(0)
-                      .map(() => [exponent[TYPE], exponent[VALUE]])
-                    exp.push(...right)
+                    if (isExponentAtom) {
+                      exp.push(exponent, [ATOM, exponent[VALUE] ** (power - 1)])
+                    } else if (isExponentWord) {
+                      exp.push(
+                        ...Array.from({ length: power })
+                          .fill(0)
+                          .map(() => [exponent[TYPE], exponent[VALUE]])
+                      )
+                    }
                   } else
                     throw new TypeError(
-                      `ArgumentS of (${
+                      `Second Arguments of (${
                         SUGGAR.POWER
-                      }), must be (or atom word) (hint use math:power instead) (${
+                      }), must be (atom) (hint use math:power instead) (${
                         SUGGAR.POWER
                       } ${stringifyArgs(rest)})`
                     )
@@ -503,15 +549,15 @@ export const deSuggar = (ast) => {
                 break
               case KEYWORDS.MULTIPLICATION:
                 if (!rest.length) {
-                  exp[0][0] = 2
-                  exp[0][1] = 1
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = TRUE
                 }
                 break
               case KEYWORDS.ADDITION:
               case KEYWORDS.DIVISION:
                 if (!rest.length) {
-                  exp[0][0] = 2
-                  exp[0][1] = 0
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = FALSE
                 }
                 break
               case SUGGAR.UNLESS:
@@ -524,9 +570,9 @@ export const deSuggar = (ast) => {
                         SUGGAR.UNLESS
                       } ${stringifyArgs(rest)})`
                     )
-                  exp[0][1] = KEYWORDS.IF
+                  exp[0][VALUE] = KEYWORDS.IF
                   const temp = exp[2]
-                  exp[2] = exp[3] ?? [ATOM, 0]
+                  exp[2] = exp[3] ?? [ATOM, FALSE]
                   exp[3] = temp
                 }
                 deSuggar(exp)
@@ -543,7 +589,7 @@ export const deSuggar = (ast) => {
                         exp[0][1]
                       } ${stringifyArgs(rest)})`
                     )
-                  exp[0][1] = KEYWORDS.NOT
+                  exp[0][VALUE] = KEYWORDS.NOT
                   exp[1] = [[APPLY, KEYWORDS.EQUAL], exp[1], exp[2]]
                   exp.length = 2
                   deSuggar(exp)