fez-lisp 1.1.24 → 1.1.26

package/README.md

@@ -246,5 +246,6 @@ console.log(fez(tree(`(+ (|> 1 (+ 2) (* 3) (- 1)) (- (* (+ 1 2) 3) 1))`)))
 (/) (+) (*) (-) (=) (<) (>) (>=) (<=) (&) (~) (|) (^) (<<) (>>) (>>>)
 (|>) (mod) (let) (if) (unless) (not) (and) (or) (cond) (atom?) (lambda)
 (car) (cdr) (cons) (length) (do) (array) (array:set!) (array:get)
-(apply) (case) (assert) (log!) (log-string!) (clear!) (void) (fez-manual)
+(apply) (case) (assert) (log!) (log-string!) (log-char!) (clear!)
+(void) (fez-manual)
 ```

package/package.json

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

package/src/compiler.js

@@ -94,6 +94,7 @@ const Helpers = {
     return args.at(-1) ? 1 : 0
   }`,
   logEffect: `logEffect=(msg)=>{console.log(msg);return msg}`,
+  logCharEffect: `logCharEffect=(msg)=>{console.log(String.fromCharCode(msg));return msg}`,
   logStringEffect: `logStringEffect=(msg)=>{console.log(msg.map(x=>String.fromCharCode(x)).join(''));return msg}`,
   clearEffect: `clearEffect=()=>{console.clear();return 0}`,
   array_cons: `array_cons=(A, ...B)=> B.reduce((a, b) => a.concat(b), A)`,

package/src/interpreter.js

@@ -859,6 +859,25 @@ const keywords = {
     console.log(expression.map((x) => String.fromCharCode(x)).join(''))
     return expression
   },
+  [KEYWORDS.LOG_CHAR]: (args, env) => {
+    if (args.length !== 1)
+      throw new RangeError(
+        `Invalid number of arguments to (${
+          KEYWORDS.LOG_CHAR
+        }) (= 1 required) (${KEYWORDS.LOG_CHAR} ${stringifyArgs(args)})`
+      )
+    const expression = evaluate(args[0], env)
+    if (typeof expression !== 'number')
+      throw new TypeError(
+        `Argument of (${KEYWORDS.LOG_CHAR}) must be a (${
+          KEYWORDS.NUMBER_TYPE
+        }) but got (${expression}) (${KEYWORDS.LOG_CHAR} ${stringifyArgs(
+          args
+        )})`
+      )
+    console.log(String.fromCharCode(expression))
+    return expression
+  },
   [KEYWORDS.CLEAR_CONSOLE]: (args) => {
     if (args.length)
       throw new RangeError(
@@ -925,33 +944,35 @@ export const deSuggar = (ast) => {
         case APPLY:
           {
             switch (first[VALUE]) {
-              case KEYWORDS.BLOCK:
-                {
-                  if (
-                    prev == undefined ||
-                    (prev &&
-                      prev[TYPE] === APPLY &&
-                      prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
-                  )
-                    throw new SyntaxError(
-                      `Can only use (${KEYWORDS.BLOCK}) as a body of a (${KEYWORDS.ANONYMOUS_FUNCTION})`
-                    )
-                }
-                break
-                // case KEYWORDS.DEFINE_VARIABLE:
-                //   {
-                //     if (
-                //       rest[1] &&
-                //       rest[1][0] &&
-                //       rest[1][0][TYPE] === APPLY &&
-                //       rest[1][0][VALUE] === KEYWORDS.BLOCK
-                //     ) {
-                //       throw new SyntaxError(
-                //         `Can't use (${KEYWORDS.BLOCK}) in (${KEYWORDS.DEFINE_VARIABLE})`
-                //       )
-                //     }
-                //   }
-                break
+              // case KEYWORDS.BLOCK:
+              //   {
+              //     if (
+              //       prev == undefined ||
+              //       (prev &&
+              //         prev[TYPE] === APPLY &&
+              //         prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
+              //     )
+              //       throw new SyntaxError(
+              //         `Can only use (${KEYWORDS.BLOCK}) as a body of a (${
+              //           KEYWORDS.ANONYMOUS_FUNCTION
+              //         }) (${stringifyArgs(exp)})`
+              //       )
+              //   }
+              //   break
+              // case KEYWORDS.DEFINE_VARIABLE:
+              //   {
+              //     if (
+              //       rest[1] &&
+              //       rest[1][0] &&
+              //       rest[1][0][TYPE] === APPLY &&
+              //       rest[1][0][VALUE] === KEYWORDS.BLOCK
+              //     ) {
+              //       throw new SyntaxError(
+              //         `Can't use (${KEYWORDS.BLOCK}) in (${KEYWORDS.DEFINE_VARIABLE})`
+              //       )
+              //     }
+              //   }
+              // break
               case KEYWORDS.PIPE:
                 {
                   if (rest.length < 1)

package/src/keywords.js

@@ -50,6 +50,7 @@ export const KEYWORDS = {
   TEST_BED: 'assert',
   LOG: 'log!',
   LOG_STRING: 'log-string!',
+  LOG_CHAR: 'log-char!',
   CLEAR_CONSOLE: 'clear!',
   DOC: 'fez-manual'
 }

package/src/utils.js

@@ -9,6 +9,7 @@ export const logError = (error) =>
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
 export const replaceStrings = (source) => {
   const quotes = source.match(/"(.*?)"/g)
+  // TODO handle escaping
   if (quotes)
     for (const q of quotes)
       source = source.replaceAll(
@@ -20,7 +21,10 @@ export const replaceStrings = (source) => {
       )
   return source
 }
-export const replaceQuotes = (source) => source.replaceAll(/\'\(/g, '(array ')
+export const replaceQuotes = (source) =>
+  source.replaceAll(/\'\(/g, '(array ').replaceAll(/\(\)/g, '(array)')
+// export const replaceEmptyArrays = (source) =>
+//   source
 export const removeNoCode = (source) =>
   source
     .replace(/;.+/g, '')