fez-lisp 1.1.23 → 1.1.25

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.23",
+  "version": "1.1.25",
   "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)`,
@@ -223,14 +224,18 @@ const compile = (tree, Drill) => {
         const vars = InnerDrills.Variables.size
           ? `var ${[...InnerDrills.Variables].join(',')};`
           : ''
-        return `((${parseArgs(
+        const args = parseArgs(
           functionArgs.map((node, index) =>
             node[VALUE] === PLACEHOLDER
               ? leaf(node[TYPE], `_${index}`)
               : leaf(node[TYPE], node[VALUE])
           ),
           InnerDrills
-        )})=>{${vars}return ${evaluatedBody.toString().trimStart()}});`
+        )
+        // const $ = [${args}];
+        return `((${args})=>{${vars}return ${evaluatedBody
+          .toString()
+          .trimStart()}});`
       }
       case KEYWORDS.AND:
         return `((${parseArgs(Arguments, Drill, '&&')}) ? 1 : 0);`

package/src/interpreter.js

@@ -317,9 +317,11 @@ const keywords = {
           } ${stringifyArgs(args)})`
         )
       const localEnv = Object.create(env)
+      // localEnv[KEYWORDS.BLOCK] = block[KEYWORDS.BLOCK]
       for (let i = 0; i < props.length; ++i) {
+        const value = evaluate(props[i], scope)
         Object.defineProperty(localEnv, params[i][VALUE], {
-          value: evaluate(props[i], scope),
+          value,
           writable: true
         })
       }
@@ -857,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(
@@ -902,7 +923,16 @@ keywords[KEYWORDS.DOC] = (args, env) => {
         .map((x) => `(${x.join(' ')})`)
   }
 }
+
 export const deSuggar = (ast) => {
+  if (ast.length === 0)
+    throw new SyntaxError(
+      `Top level ${KEYWORDS.NUMBER_TYPE} need to be wrapped in a (${KEYWORDS.IDENTITY})`
+    )
+  // for (const node of ast)
+  //   if (node[0] && node[0][TYPE] === APPLY && node[0][VALUE] === KEYWORDS.BLOCK)
+  //     throw new SyntaxError(`Top level (${KEYWORDS.BLOCK}) is not allowed`)
+  let prev = undefined
   const evaluate = (exp) => {
     const [first, ...rest] = isLeaf(exp) ? [exp] : exp
     if (first != undefined) {
@@ -914,6 +944,33 @@ 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.PIPE:
                 {
                   if (rest.length < 1)
@@ -957,6 +1014,7 @@ export const deSuggar = (ast) => {
                 }
                 break
             }
+            prev = first
           }
           break
         default:

package/src/keywords.js

@@ -5,9 +5,9 @@ export const WORD = 1
 export const ATOM = 2
 export const PLACEHOLDER = '.'
 export const KEYWORDS = {
-  RECURSION: 'rec',
   NUMBER_TYPE: 'number',
   ARRAY_TYPE: 'array',
+  IDENTITY: 'identity',
   ARRAY_LENGTH: 'length',
   IS_ATOM: 'atom?',
   ADDITION: '+',
@@ -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, '')
@@ -233,10 +237,6 @@ export const fez = (source, options = {}) => {
       if (!options.mutation) code = removeMutation(code)
       if (!code.length && options.throw) throw new Error('Nothing to parse!')
       const parsed = deSuggar(LISP.parse(code))
-      if (parsed.length === 0 && options.throw)
-        throw new Error(
-          'Top level expressions need to be wrapped in a (do) block'
-        )
       const ast = [...treeShake(parsed, std), ...parsed]
       // if (options.check) typeCheck(ast)
       if (options.compile) {