fez-lisp 1.0.22 → 1.0.24

package/package.json

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

package/src/compiler.js

@@ -7,6 +7,7 @@ import {
   VALUE,
   WORD,
 } from './enums.js'
+import { leaf, isLeaf } from './parser.js'
 import { deepRename, lispToJavaScriptVariableName } from './utils.js'
 const Helpers = {
   log: `var logEffect=(msg)=>{console.log(msg);return msg}`,
@@ -28,14 +29,6 @@ return result
   isAtom: `atomPredicate=(value)=>typeof value==='number'||typeof value==='string'`,
   error: `_error=(error)=>{ 
     throw new Error(error)
-}`,
-  arraySet: `arraySet=(array,index,value)=>{ 
-  array=[...array]
-  if (index < 0) {
-   const target = array.length + index
-   while (array.length !== target) array.pop()
-  } else array[index] = value; 
-  return array 
 }`,
   arraySetEffect: `arraySetEffect=(array,index,value)=>{ 
     if (index < 0) {
@@ -45,7 +38,7 @@ return result
     return array 
 }`,
   serialise:
-    "serialise=(ast)=>{\n if(ast==undefined) return '()'\n else if(typeofast==='object')\n if(Array.isArray(ast)) return `(array ${ast.map(stringify).join(' ')})`\n else\n return `(array ${Object.entries(ast).map(([key, value]) => `(\"${key}\" ${stringify(value)})`).join(' ')})`\n else if(typeofast==='string') return `\"${ast}\"`\n else if(typeofast==='function') return '()'\n else return ast\n}",
+    "serialise=(ast)=>{\n if(ast==undefined) return '()'\n else if(typeof ast==='object')\n if(Array.isArray(ast)) return `(array ${ast.map(stringify).join(' ')})`\n else\n return `(array ${ast.map(([key, value]) => `(\"${key}\" ${stringify(value)})`).join(' ')})`\n else if(typeof ast==='string') return `\"${ast}\"`\n else if(typeof ast==='function') return '()'\n else return ast\n}",
   cast: `_cast=(type,value)=>{
     switch (type) {
       case '${KEYWORDS.NUMBER_TYPE}':
@@ -95,7 +88,7 @@ const parseArgs = (Arguments, Variables, separator = ',') =>
   parse(Arguments, Variables).join(separator)
 const compile = (tree, Variables) => {
   if (!tree) return ''
-  const [first, ...Arguments] = Array.isArray(tree) ? tree : [tree]
+  const [first, ...Arguments] = !isLeaf(tree) ? tree : [tree]
   if (first == undefined) return '[];'
   const token = first[VALUE]
   if (first[TYPE] === APPLY) {
@@ -186,8 +179,8 @@ const compile = (tree, Variables) => {
         return `((${parseArgs(
           functionArgs.map((node, index) =>
             node[VALUE] === PLACEHOLDER
-              ? { [TYPE]: node[TYPE], [VALUE]: `_${index}` }
-              : { [TYPE]: node[TYPE], [VALUE]: node[VALUE] }
+              ? leaf(node[TYPE], `_${index}`)
+              : leaf(node[TYPE], node[VALUE])
           ),
           Variables
         )})=>{${vars}return ${evaluatedBody.toString().trimStart()}});`
@@ -318,15 +311,10 @@ const compile = (tree, Variables) => {
       }
       case KEYWORDS.IMMUTABLE_FUNCTION: {
         const [first, ...rest] = Arguments
-        return compile(
-          [{ [TYPE]: APPLY, [VALUE]: first[VALUE] }, ...rest],
-          Variables
-        )
+        return compile([leaf(APPLY, first[VALUE]), ...rest], Variables)
       }
       case KEYWORDS.SERIALISE:
         return `serialise(${compile(Arguments[0], Variables)});`
-      case KEYWORDS.SET_IMMUTABLE_ARRAY:
-        return `arraySet(${parseArgs(Arguments, Variables)});`
       case KEYWORDS.SET_ARRAY:
         return `arraySetEffect(${parseArgs(Arguments, Variables)});`
       case KEYWORDS.NOT_COMPILED_BLOCK:

package/src/enums.js

@@ -1,8 +1,8 @@
 // AST enums
+export const TYPE = 0
+export const VALUE = 1
 export const WORD = 'w'
 export const APPLY = 'f'
-export const VALUE = 'v'
-export const TYPE = 't'
 export const ATOM = 'a'
 // tokeniser enums
 export const PLACEHOLDER = '.'
@@ -77,5 +77,4 @@ export const KEYWORDS = {
   SERIALISE: 'serialise',
 
   SET_ARRAY: 'array:set!',
-  SET_IMMUTABLE_ARRAY: 'array:set',
 }

package/src/interpreter.js

@@ -1,9 +1,10 @@
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './enums.js'
+import { isLeaf } from './parser.js'
 import { keywords } from './tokeniser.js'
 import { stringifyArgs } from './utils.js'
 
 export const evaluate = (exp, env) => {
-  const [first, ...rest] = Array.isArray(exp) ? exp : [exp]
+  const [first, ...rest] = !isLeaf(exp) ? exp : [exp]
   if (first == undefined) return []
   switch (first[TYPE]) {
     case WORD: {

package/src/parser.js

@@ -1,6 +1,7 @@
-import { APPLY, ATOM, TYPE, VALUE, WORD } from './enums.js'
+import { APPLY, ATOM, WORD } from './enums.js'
 import { escape } from './utils.js'
-
+export const leaf = (type, value) => [type, value]
+export const isLeaf = (tree) => typeof tree[0] === 'string'
 export const parse = (source) => {
   const tree = []
   let head = tree,
@@ -25,18 +26,12 @@ export const parse = (source) => {
       let token = acc
       acc = ''
       if (token) {
-        if (!head.length) head.push({ [TYPE]: APPLY, [VALUE]: token })
+        if (!head.length) head.push(leaf(APPLY, token))
         else if (token.match(/^"([^"]*)"/))
-          head.push({
-            [TYPE]: ATOM,
-            [VALUE]: token.substring(1, token.length - 1),
-          })
+          head.push(leaf(ATOM, token.substring(1, token.length - 1)))
         else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
-          head.push({
-            [TYPE]: ATOM,
-            [VALUE]: Number(token),
-          })
-        else head.push({ [TYPE]: WORD, [VALUE]: token })
+          head.push(leaf(ATOM, Number(token)))
+        else head.push(leaf(WORD, token))
       }
       if (cursor === ')') head = stack.pop()
     } else acc += cursor
@@ -46,10 +41,10 @@ export const parse = (source) => {
 export const stringify = (ast) => {
   if (ast == undefined) return '()'
   else if (typeof ast === 'object')
-    if (Array.isArray(ast))
+    if (!isLeaf(ast))
       return ast.length ? `(array ${ast.map(stringify).join(' ')})` : '()'
     else
-      return `(array ${Object.entries(ast)
+      return `(array ${ast
         .map(([key, value]) => `("${key}" ${stringify(value)})`)
         .join(' ')})`
   else if (typeof ast === 'string') return `"${ast}"`

package/src/tokeniser.js

@@ -1,4 +1,4 @@
-import { TYPE, VALUE, WORD, KEYWORDS } from './enums.js'
+import { TYPE, VALUE, WORD, KEYWORDS, APPLY } from './enums.js'
 import { evaluate } from './interpreter.js'
 import { stringify } from './parser.js'
 import {
@@ -14,9 +14,9 @@ const keywords = {
     if (args.length < 2)
       throw new RangeError(
         `Invalid number of arguments for (${
-          keywords.CONCATENATION
+          KEYWORDS.CONCATENATION
         }), expected > 1 but got ${args.length}. (${
-          keywords.CONCATENATION
+          KEYWORDS.CONCATENATION
         } ${stringifyArgs(args)})`
       )
     const operands = args.map((x) => evaluate(x, env))
@@ -870,11 +870,13 @@ const keywords = {
       )
     let inp = args[0]
     for (let i = 1; i < args.length; ++i) {
-      if (!Array.isArray(args[i]))
+      if (!args[i].length || args[i][0][TYPE] !== APPLY)
         throw new TypeError(
-          `Argument at position (${i}) of (${KEYWORDS.PIPE}) is not a (${
-            KEYWORDS.ANONYMOUS_FUNCTION
-          }). (${KEYWORDS.PIPE} ${stringifyArgs(args)})`
+          `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]
@@ -1088,86 +1090,6 @@ const keywords = {
     }
     return array
   },
-
-  [KEYWORDS.SET_IMMUTABLE_ARRAY]: (args, env) => {
-    if (args.length !== 2 && args.length !== 3)
-      throw new RangeError(
-        `Invalid number of arguments for (${
-          KEYWORDS.SET_IMMUTABLE_ARRAY
-        }) (or 2 3) required (${KEYWORDS.SET_IMMUTABLE_ARRAY} ${stringifyArgs(
-          args
-        )})`
-      )
-    let array = evaluate(args[0], env)
-    if (!Array.isArray(array))
-      throw new TypeError(
-        `First argument of (${KEYWORDS.SET_IMMUTABLE_ARRAY}) must be an (${
-          KEYWORDS.ARRAY_TYPE
-        }) but got (${array}) (${KEYWORDS.SET_IMMUTABLE_ARRAY} ${stringifyArgs(
-          args
-        )})`
-      )
-    array = [...array]
-    const index = evaluate(args[1], env)
-    if (!Number.isInteger(index))
-      throw new TypeError(
-        `Second argument of (${KEYWORDS.SET_IMMUTABLE_ARRAY}) must be an (${
-          KEYWORDS.NUMBER_TYPE
-        } integer) (${index}) (${KEYWORDS.SET_IMMUTABLE_ARRAY} ${stringifyArgs(
-          args
-        )})`
-      )
-    if (index > array.length)
-      throw new RangeError(
-        `Second argument of (${
-          KEYWORDS.SET_IMMUTABLE_ARRAY
-        }) is outside of the (${
-          KEYWORDS.ARRAY_TYPE
-        }) bounds (index ${index} bounds ${array.length}) (${
-          KEYWORDS.SET_IMMUTABLE_ARRAY
-        } ${stringifyArgs(args)})`
-      )
-    if (index < 0) {
-      if (args.length !== 2)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          }) (if (< index 0) then 2 required) (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      if (index * -1 > array.length)
-        throw new RangeError(
-          `Second argument of (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          }) is outside of the (${
-            KEYWORDS.ARRAY_TYPE
-          }) bounds (index ${index} bounds ${array.length}) (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      const target = array.length + index
-      while (array.length !== target) array.pop()
-    } else {
-      if (args.length !== 3)
-        throw new RangeError(
-          `Invalid number of arguments for (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          }) (if (>= index 0) then 3 required) (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          } ${stringifyArgs(args)})`
-        )
-      const value = evaluate(args[2], env)
-      if (value == undefined)
-        throw new RangeError(
-          `Trying to set a null value in (${KEYWORDS.ARRAY_TYPE}) at (${
-            KEYWORDS.SET_IMMUTABLE_ARRAY
-          }). (${KEYWORDS.SET_IMMUTABLE_ARRAY} ${stringifyArgs(args)})`
-        )
-      array[index] = value
-    }
-    return array
-  },
 }
 keywords[KEYWORDS.NOT_COMPILED_BLOCK] = keywords[KEYWORDS.BLOCK]
 export { keywords }

package/src/utils.js

@@ -1,8 +1,16 @@
 import std from '../lib/baked/std.js'
 import { comp } from './compiler.js'
-import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './enums.js'
+import {
+  APPLY,
+  ATOM,
+  KEYWORDS,
+  PLACEHOLDER,
+  TYPE,
+  VALUE,
+  WORD,
+} from './enums.js'
 import { evaluate, run } from './interpreter.js'
-import { parse } from './parser.js'
+import { isLeaf, parse } from './parser.js'
 export const logError = (error) => console.log('\x1b[31m', error, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
 export const removeNoCode = (source) =>
@@ -39,13 +47,13 @@ export const escape = (Char) => {
   }
 }
 export const stringifyType = (type) =>
-  Array.isArray(type)
+  !isLeaf(type)
     ? `(array ${type.map((t) => stringifyType(t)).join(' ')})`
     : typeof type
 export const stringifyArgs = (args) =>
   args
     .map((x) =>
-      Array.isArray(x)
+      !isLeaf(x)
         ? `(${stringifyArgs(x)})`
         : x[TYPE] === APPLY || x[TYPE] === WORD
         ? x[VALUE]
@@ -132,7 +140,7 @@ export const treeShake = (ast, libs) => {
   const deps = libs.reduce((a, x) => a.add(x.at(1)[VALUE]), new Set())
   const visited = new Set()
   const dfs = (tree) => {
-    if (Array.isArray(tree)) tree.forEach(dfs)
+    if (!isLeaf(tree)) tree.forEach(dfs)
     else if (
       (tree[TYPE] === APPLY || tree[TYPE] === WORD) &&
       deps.has(tree[VALUE]) &&
@@ -153,20 +161,18 @@ export const runFromCompiled = (source) => {
   const tree = parse(
     handleUnbalancedQuotes(handleUnbalancedParens(removeNoCode(source)))
   )
-  if (Array.isArray(tree)) {
-    const compiled = comp(tree)
-    const JavaScript = `${compiled.top}${compiled.program}`
-    return eval(JavaScript)
-  }
+  const compiled = comp(tree)
+  const JavaScript = `${compiled.top}${compiled.program}`
+  return eval(JavaScript)
 }
 export const runFromInterpreted = (source, env = {}) => {
   const tree = parse(
     handleUnbalancedQuotes(handleUnbalancedParens(removeNoCode(source)))
   )
-  if (Array.isArray(tree)) return run(tree, env)
+  run(tree, env)
 }
 export const dfs = (tree, callback) => {
-  if (Array.isArray(tree)) for (const branch of tree) dfs(branch)
+  if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
   else callback(tree)
 }
 export const deepClone = (ast) => JSON.parse(JSON.stringify(ast))
@@ -180,7 +186,12 @@ export const fez = (source, options = {}) => {
       )
     else code = removeNoCode(source)
     if (!options.mutation) code = removeMutation(code)
+    if (!code.length && options.throw) throw new Error('Nothing to parse!')
     const parsed = parse(code)
+    if (parsed.length === 0 && options.throw)
+      throw new Error(
+        'Top level expressions need to be wrapped in a (do) block'
+      )
     const standard = options.std
       ? options.shake
         ? treeShake(parsed, std)
@@ -196,9 +207,8 @@ export const fez = (source, options = {}) => {
     const err = error.message
       .replace("'[object Array]'", '(array)')
       .replace('object', '(array)')
-    if (options.errors) {
-      logError(err)
-    }
+    if (options.errors) logError(err)
+    if (options.throw) throw err
     return err
   }
 }
@@ -227,12 +237,12 @@ export const toCamelCase = (name) => {
   return out
 }
 export const deepRename = (name, newName, tree) => {
-  if (Array.isArray(tree))
-    for (const branch of tree) {
+  if (!isLeaf(tree))
+    for (const leaf of tree) {
       // Figure out a non mutable solution so
       // I can get rid of deep copy
-      if (branch[VALUE] === name) branch[VALUE] = `()=>${newName}`
-      deepRename(name, newName, branch)
+      if (leaf[VALUE] === name) leaf[VALUE] = `()=>${newName}`
+      deepRename(name, newName, leaf)
     }
 }
 export const lispToJavaScriptVariableName = (name) =>