fez-lisp 1.2.48 → 1.2.50

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.2.48",
+  "version": "1.2.50",
   "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()

package/src/interpreter.js

@@ -651,29 +651,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: '//',
+
+  RECURSION: 'recursive',
+  CACHE: 'memoized'
+}
 export const KEYWORDS = {
   NUMBER_TYPE: 'number',
   ARRAY_TYPE: 'array',
@@ -49,17 +62,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,6 @@
 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, KEYWORDS, SUGGAR, 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 +102,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])
@@ -410,13 +410,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 +426,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,7 +437,7 @@ export const deSuggar = (ast) => {
                   deSuggar(exp)
                 }
                 break
-              case KEYWORDS.LIST_TYPE:
+              case SUGGAR.LIST_TYPE:
                 {
                   exp.length = 0
                   let temp = exp
@@ -449,6 +449,58 @@ export const deSuggar = (ast) => {
                   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, 0])
+                  }
+                }
+                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)})`
+                    )
+                  if (
+                    (exp[2][TYPE] === ATOM || exp[2][TYPE] === WORD) &&
+                    (exp[1][TYPE] === WORD || exp[1][TYPE] === ATOM)
+                  ) {
+                    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)
+                  } else
+                    throw new TypeError(
+                      `ArgumentS of (${
+                        SUGGAR.POWER
+                      }), must be (or atom word) (hint use math:power instead) (${
+                        SUGGAR.POWER
+                      } ${stringifyArgs(rest)})`
+                    )
+                }
+                break
               case KEYWORDS.MULTIPLICATION:
                 if (!rest.length) {
                   exp[0][0] = 2
@@ -462,14 +514,14 @@ export const deSuggar = (ast) => {
                   exp[0][1] = 0
                 }
                 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
@@ -480,8 +532,8 @@ export const deSuggar = (ast) => {
                 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(