fez-lisp 1.2.49 → 1.2.53

package/package.json

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

package/src/compiler.js

@@ -5,7 +5,8 @@ import {
   KEYWORDS,
   TYPE,
   VALUE,
-  WORD
+  WORD,
+  SUGGAR
 } from './keywords.js'
 import { leaf, isLeaf } from './parser.js'
 const deepRenameTco = (name, newName, tree) => {
@@ -176,9 +177,9 @@ const compile = (tree, Drill) => {
       case KEYWORDS.DEFINE_VARIABLE: {
         const n = Arguments[0][VALUE]
         const prefix = n.split(':')[0]
-        if (prefix === KEYWORDS.RECURSION) {
+        if (prefix === SUGGAR.RECURSION) {
           const name = lispToJavaScriptVariableName(n)
-          const newName = `recursive_${performance
+          const newName = `${SUGGAR.RECURSION}_${performance
             .now()
             .toString()
             .replace('.', 7)}`
@@ -199,10 +200,10 @@ const compile = (tree, Drill) => {
           )})=>{${vars}return ${evaluatedBody
             .toString()
             .trim()}}, ${newName})));`
-        } else if (prefix === KEYWORDS.CACHE) {
+        } else if (prefix === SUGGAR.CACHE) {
           // memoization here
           const name = lispToJavaScriptVariableName(n)
-          const newName = name.substring(KEYWORDS.CACHE.length + 1)
+          const newName = name.substring(SUGGAR.CACHE.length + 1)
           Drill.Variables.add(name)
           const functionArgs = Arguments.at(-1).slice(1)
           const body = functionArgs.pop()
@@ -312,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)) : []
   },
@@ -651,29 +620,6 @@ export const keywords = {
       )
     return operands.reduce((acc, x) => acc >>> x)
   },
-  // [KEYWORDS.PIPE]: (args, env) => {
-  //   if (args.length < 1)
-  //     throw new RangeError(
-  //       `Invalid number of arguments to (${KEYWORDS.PIPE}) (>= 1 required). (${
-  //         KEYWORDS.PIPE
-  //       } ${stringifyArgs(args)})`
-  //     )
-  //   let inp = args[0]
-  //   for (let i = 1; i < args.length; ++i) {
-  //     if (!args[i].length || args[i][0][TYPE] !== APPLY)
-  //       throw new TypeError(
-  //         `Argument at position (${i}) of (${
-  //           KEYWORDS.PIPE
-  //         }) is not an invoked (${KEYWORDS.ANONYMOUS_FUNCTION}). (${
-  //           KEYWORDS.PIPE
-  //         } ${stringifyArgs(args)})`
-  //       )
-  //     const [first, ...rest] = args[i]
-  //     const arr = [first, inp, ...rest]
-  //     inp = arr
-  //   }
-  //   return evaluate(inp, env)
-  // },
   [KEYWORDS.SET_ARRAY]: (args, env) => {
     if (args.length !== 1 && args.length !== 3)
       throw new RangeError(

package/src/keywords.js

@@ -6,6 +6,19 @@ export const ATOM = 2
 export const TRUE = 1
 export const FALSE = 0
 export const PLACEHOLDER = '.'
+export const SUGGAR = {
+  // Syntactic suggars
+  PIPE: '|>',
+  NOT_EQUAL_1: '!=',
+  NOT_EQUAL_2: '<>',
+  UNLESS: 'unless',
+  LIST_TYPE: 'list',
+  POWER: '**',
+  INTEGER_DEVISION: '//',
+  CONDITION: 'cond',
+  RECURSION: 'recursive',
+  CACHE: 'memoized'
+}
 export const KEYWORDS = {
   NUMBER_TYPE: 'number',
   ARRAY_TYPE: 'array',
@@ -29,7 +42,6 @@ export const KEYWORDS = {
   BLOCK: 'do',
   ANONYMOUS_FUNCTION: 'lambda',
   IF: 'if',
-  CONDITION: 'cond',
   NOT: 'not',
   EQUAL: '=',
   LESS_THAN: '<',
@@ -49,17 +61,7 @@ export const KEYWORDS = {
   LOG_CHAR: 'log-char!',
   CLEAR_CONSOLE: 'clear!',
 
-  THROW: 'throw',
-
-  // Syntactic suggars
-  PIPE: '|>',
-  NOT_EQUAL_1: '!=',
-  NOT_EQUAL_2: '<>',
-  UNLESS: 'unless',
-  LIST_TYPE: 'list',
-
-  RECURSION: 'recursive',
-  CACHE: 'memoized'
+  THROW: 'throw'
 }
 
 export const TYPES = {

package/src/utils.js

@@ -1,6 +1,16 @@
 import std from '../lib/baked/std.js'
 import { comp } from './compiler.js'
-import { APPLY, ATOM, KEYWORDS, 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) =>
@@ -102,8 +112,8 @@ export const isForbiddenVariableName = (name) => {
   switch (name) {
     case '_':
     case KEYWORDS.DEFINE_VARIABLE:
-    case KEYWORDS.RECURSION:
-    case KEYWORDS.CACHE:
+    case SUGGAR.RECURSION:
+    case SUGGAR.CACHE:
       return true
     default:
       return !isNaN(name[0])
@@ -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],
@@ -410,13 +420,13 @@ export const deSuggar = (ast) => {
               //     }
               //   }
               // break
-              case KEYWORDS.PIPE:
+              case SUGGAR.PIPE:
                 {
                   if (rest.length < 1)
                     throw new RangeError(
                       `Invalid number of arguments to (${
-                        KEYWORDS.PIPE
-                      }) (>= 1 required). (${KEYWORDS.PIPE} ${stringifyArgs(
+                        SUGGAR.PIPE
+                      }) (>= 1 required). (${SUGGAR.PIPE} ${stringifyArgs(
                         rest
                       )})`
                     )
@@ -426,10 +436,10 @@ export const deSuggar = (ast) => {
                     if (!rest[i].length || rest[i][0][TYPE] !== APPLY)
                       throw new TypeError(
                         `Argument at position (${i}) of (${
-                          KEYWORDS.PIPE
+                          SUGGAR.PIPE
                         }) is not an invoked (${
                           KEYWORDS.ANONYMOUS_FUNCTION
-                        }). (${KEYWORDS.PIPE} ${stringifyArgs(rest)})`
+                        }). (${SUGGAR.PIPE} ${stringifyArgs(rest)})`
                       )
                     inp = [rest[i].shift(), inp, ...rest[i]]
                   }
@@ -437,51 +447,139 @@ export const deSuggar = (ast) => {
                   deSuggar(exp)
                 }
                 break
-              case KEYWORDS.LIST_TYPE:
+              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
+              case SUGGAR.INTEGER_DEVISION:
+                {
+                  if (rest.some((x) => x[TYPE] === APPLY))
+                    throw new TypeError(
+                      `Arguments of (${
+                        SUGGAR.INTEGER_DEVISION
+                      }), must be (or atom word) (hint use (math:floor (${
+                        KEYWORDS.DIVISION
+                      } a b)) instead) (${
+                        SUGGAR.INTEGER_DEVISION
+                      } ${stringifyArgs(rest)})`
+                    )
+                  else {
+                    exp.length = 1
+                    exp[0] = [APPLY, KEYWORDS.BITWISE_OR]
+                    exp.push([[APPLY, KEYWORDS.DIVISION], ...rest])
+                    exp.push([ATOM, FALSE])
+                  }
+                }
+                break
+              case SUGGAR.POWER:
+                {
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.POWER
+                      }), expected (= 2) but got ${rest.length} (${
+                        SUGGAR.POWER
+                      } ${stringifyArgs(rest)})`
+                    )
+                  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
+                    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(
+                      `Second Arguments of (${
+                        SUGGAR.POWER
+                      }), must be (atom) (hint use math:power instead) (${
+                        SUGGAR.POWER
+                      } ${stringifyArgs(rest)})`
+                    )
+                }
+                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 KEYWORDS.UNLESS:
+              case SUGGAR.UNLESS:
                 {
                   if (rest.length > 3 || rest.length < 2)
                     throw new RangeError(
                       `Invalid number of arguments for (${
-                        KEYWORDS.UNLESS
+                        SUGGAR.UNLESS
                       }), expected (or (= 3) (= 2)) but got ${rest.length} (${
-                        KEYWORDS.UNLESS
+                        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)
                 break
 
-              case KEYWORDS.NOT_EQUAL_1:
-              case KEYWORDS.NOT_EQUAL_2:
+              case SUGGAR.NOT_EQUAL_1:
+              case SUGGAR.NOT_EQUAL_2:
                 {
                   if (rest.length > 3 || rest.length < 2)
                     throw new RangeError(
@@ -491,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)