fez-lisp 1.3.8 → 1.3.10

package/package.json

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

package/src/compiler.js

@@ -121,8 +121,7 @@ const Helpers = {
   __tco: `__tco=fn=>(...args)=>{let result=fn(...args);while(typeof result==='function')result=result();return result}`,
   atom_predicate: `atom_predicate=(number)=>+(typeof number==='number')`,
   lambda_predicate: `lambda_predicate=(fm)=>+(typeof fn==='function')`,
-  set_effect: `set_effect=function(array,index,value){if(arguments.length===1){array.pop()}else{array[index] = value};return array}`,
-  __error: `__error=(error)=>{throw new Error(error.map((x)=>String.fromCharCode(x)).join(''))}`
+  set_effect: `set_effect=function(array,index,value){if(arguments.length===1){array.pop()}else{array[index] = value};return array}`
 }
 const semiColumnEdgeCases = new Set([
   ';)',
@@ -313,10 +312,6 @@ const compile = (tree, Drill) => {
           Drill
         )}:${Arguments.length === 3 ? compile(Arguments[2], Drill) : 0});`
       }
-      case KEYWORDS.THROW: {
-        Drill.Helpers.add('__error')
-        return `__error(${compile(Arguments[0], Drill)})`
-      }
       default: {
         const camelCased = lispToJavaScriptVariableName(token)
         if (camelCased in Helpers) Drill.Helpers.add(camelCased)

package/src/evaluator.js

@@ -33,5 +33,3 @@ export const evaluate = (exp, env) => {
       )
   }
 }
-export const run = (tree, env = {}) =>
-  keywords[KEYWORDS.BLOCK](tree, { ...keywords, ...env })

package/src/interpreter.js

@@ -702,23 +702,6 @@ export const keywords = {
       )
     return +(typeof evaluate(args[0], env) === 'function')
   },
-  // Not sure about these
-  [KEYWORDS.THROW]: (args, env) => {
-    if (args.length !== 1)
-      throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.THROW}) (= 1 required) (${
-          KEYWORDS.THROW
-        } ${stringifyArgs(args)})`
-      )
-    const expression = evaluate(args[0], env)
-    if (!Array.isArray(expression))
-      throw new TypeError(
-        `Argument of (${KEYWORDS.THROW}) must be an (${
-          RUNTIME_TYPES.ARRAY
-        }) but got (${expression}) (${KEYWORDS.THROW} ${stringifyArgs(args)})`
-      )
-    throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
-  },
   [KEYWORDS.LOG]: (args, env) => {
     if (args.length !== 1)
       throw new RangeError(

package/src/keywords.js

@@ -44,9 +44,7 @@ export const KEYWORDS = {
   LOG: 'log!',
   LOG_STRING: 'log-string!',
   LOG_CHAR: 'log-char!',
-  CLEAR_CONSOLE: 'clear!',
-
-  THROW: 'throw'
+  CLEAR_CONSOLE: 'clear!'
 }
 
 export const TYPES = {

package/src/parser.js

@@ -1,138 +1,138 @@
-import { APPLY, ATOM, TYPE, WORD, VALUE } from './keywords.js'
-export const leaf = (type, value) => [type, value]
-export const isLeaf = ([car]) => car === APPLY || car === ATOM || car === WORD
-export const LISP = {
-  parse: (source) => {
-    const tree = []
-    const stack = [tree]
-    let head = tree
-    let acc = ''
-    for (let i = 0; i < source.length; ++i) {
-      const cursor = source[i]
-      if (cursor === '(') {
-        const temp = []
-        head.push(temp)
-        stack.push(head)
-        head = temp
-      } else if (cursor === ')' || cursor === ' ') {
-        let token = acc
-        acc = ''
-        if (token) {
-          if (!head.length) head.push(leaf(APPLY, token))
-          else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
-            head.push(leaf(ATOM, Number(token)))
-          else head.push(leaf(WORD, token))
-        }
-        if (cursor === ')') head = stack.pop()
-      } else acc += cursor
-    }
-    return tree
-  },
-  stringify: (array) => {
-    if (array == undefined) return '()'
-    else if (typeof array === 'object')
-      if (Array.isArray(array))
-        return array.length
-          ? `(array ${array.map(LISP.stringify).join(' ')})`
-          : '()'
-      else
-        return `(array ${array
-          .map(([key, value]) => `("${key}" ${LISP.stringify(value)})`)
-          .join(' ')})`
-    else if (typeof array === 'function') return '()'
-    else if (typeof array === 'boolean') return +array
-    else return array
-  },
-  source: (ast) => {
-    const dfs = (exp) => {
-      let out = ''
-      const [first, ...rest] = isLeaf(exp) ? [exp] : exp
-      if (first == undefined) return (out += '()')
-      switch (first[TYPE]) {
-        case WORD:
-          out += first[VALUE]
-          break
-        case ATOM:
-          out += first[VALUE]
-          break
-        case APPLY:
-          out += `(${first[VALUE]} ${rest.map(dfs).join(' ')})`
-          break
-      }
-      return out
-    }
-    return ast.map(dfs).join(' ')
-  }
-}
-export const AST = {
-  parse: (source) => {
-    const tree = []
-    const stack = [tree]
-    let head = tree
-    let acc = ''
-    for (let i = 0; i < source.length; ++i) {
-      const cursor = source[i]
-      if (cursor === '"') {
-        acc += '"'
-        ++i
-        while (source[i] !== '"') {
-          acc += source[i]
-          ++i
-        }
-      }
-      if (cursor === '[') {
-        const temp = []
-        head.push(temp)
-        stack.push(head)
-        head = temp
-      } else if (cursor === ']' || cursor === ',') {
-        let token = acc
-        acc = ''
-        if (token) {
-          if (!head.length) head.push(Number(token))
-          else if (token[0] === '"' && token[token.length - 1] === '"')
-            head.push(token.substring(1, token.length - 1))
-          else head.push(Number(token))
-        }
-        if (cursor === ']') head = stack.pop()
-      } else acc += cursor
-    }
-    return tree[0]
-  },
-  stringify: (ast) =>
-    typeof ast === 'object'
-      ? `[${ast.map(AST.stringify).join(',')}]`
-      : typeof ast === 'string'
-      ? `"${ast}"`
-      : ast,
-  struct: (ast) => {
-    const dfs = (exp) => {
-      let out = ''
-      const [first, ...rest] = isLeaf(exp) ? [exp] : exp
-      if (first == undefined)
-        return (out +=
-          '(Expression::Apply(vec![Expression::Word("array".to_string())]))')
-      switch (first[TYPE]) {
-        case WORD:
-          out += `Expression::Word("${first[VALUE]}".to_string())`
-          break
-        case ATOM:
-          out += `Expression::Atom(${
-            Number.isInteger(first[VALUE])
-              ? `${first[VALUE]}.0`
-              : first[VALUE].toString()
-          })`
-          break
-        case APPLY:
-          out += `Expression::Apply(vec![Expression::Word("${
-            first[VALUE]
-          }".to_string()),${rest.map(dfs).join(',')}])`
-          break
-      }
-      return out
-    }
-    return `Expression::Apply(vec![Expression::Word("do".to_string()),${ast
-      .map(dfs)
-      .join(',')}])`
-  }
-}
+import { APPLY, ATOM, TYPE, WORD, VALUE } from './keywords.js'
+export const leaf = (type, value) => [type, value]
+export const isLeaf = ([car]) => car === APPLY || car === ATOM || car === WORD
+export const LISP = {
+  parse: (source) => {
+    const tree = []
+    const stack = [tree]
+    let head = tree
+    let acc = ''
+    for (let i = 0; i < source.length; ++i) {
+      const cursor = source[i]
+      if (cursor === '(') {
+        const temp = []
+        head.push(temp)
+        stack.push(head)
+        head = temp
+      } else if (cursor === ')' || cursor === ' ') {
+        let token = acc
+        acc = ''
+        if (token) {
+          if (!head.length) head.push(leaf(APPLY, token))
+          else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
+            head.push(leaf(ATOM, Number(token)))
+          else head.push(leaf(WORD, token))
+        }
+        if (cursor === ')') head = stack.pop()
+      } else acc += cursor
+    }
+    return tree
+  },
+  stringify: (array) => {
+    if (array == undefined) return '()'
+    else if (typeof array === 'object')
+      if (Array.isArray(array))
+        return array.length
+          ? `(array ${array.map(LISP.stringify).join(' ')})`
+          : '()'
+      else
+        return `(array ${array
+          .map(([key, value]) => `("${key}" ${LISP.stringify(value)})`)
+          .join(' ')})`
+    else if (typeof array === 'function') return '()'
+    else if (typeof array === 'boolean') return +array
+    else return array
+  },
+  source: (ast) => {
+    const dfs = (exp) => {
+      let out = ''
+      const [first, ...rest] = isLeaf(exp) ? [exp] : exp
+      if (first == undefined) return (out += '()')
+      switch (first[TYPE]) {
+        case WORD:
+          out += first[VALUE]
+          break
+        case ATOM:
+          out += first[VALUE]
+          break
+        case APPLY:
+          out += `(${first[VALUE]} ${rest.map(dfs).join(' ')})`
+          break
+      }
+      return out
+    }
+    return ast.map(dfs).join(' ')
+  }
+}
+export const AST = {
+  parse: (source) => {
+    const tree = []
+    const stack = [tree]
+    let head = tree
+    let acc = ''
+    for (let i = 0; i < source.length; ++i) {
+      const cursor = source[i]
+      if (cursor === '"') {
+        acc += '"'
+        ++i
+        while (source[i] !== '"') {
+          acc += source[i]
+          ++i
+        }
+      }
+      if (cursor === '[') {
+        const temp = []
+        head.push(temp)
+        stack.push(head)
+        head = temp
+      } else if (cursor === ']' || cursor === ',') {
+        let token = acc
+        acc = ''
+        if (token) {
+          if (!head.length) head.push(Number(token))
+          else if (token[0] === '"' && token[token.length - 1] === '"')
+            head.push(token.substring(1, token.length - 1))
+          else head.push(Number(token))
+        }
+        if (cursor === ']') head = stack.pop()
+      } else acc += cursor
+    }
+    return tree
+  },
+  stringify: (ast) =>
+    typeof ast === 'object'
+      ? `[${ast.map(AST.stringify).join(',')}]`
+      : typeof ast === 'string'
+      ? `"${ast}"`
+      : ast,
+  struct: (ast) => {
+    const dfs = (exp) => {
+      let out = ''
+      const [first, ...rest] = isLeaf(exp) ? [exp] : exp
+      if (first == undefined)
+        return (out +=
+          '(Expression::Apply(vec![Expression::Word("array".to_string())]))')
+      switch (first[TYPE]) {
+        case WORD:
+          out += `Expression::Word("${first[VALUE]}".to_string())`
+          break
+        case ATOM:
+          out += `Expression::Atom(${
+            Number.isInteger(first[VALUE])
+              ? `${first[VALUE]}.0`
+              : first[VALUE].toString()
+          })`
+          break
+        case APPLY:
+          out += `Expression::Apply(vec![Expression::Word("${
+            first[VALUE]
+          }".to_string()),${rest.map(dfs).join(',')}])`
+          break
+      }
+      return out
+    }
+    return `Expression::Apply(vec![Expression::Word("do".to_string()),${ast
+      .map(dfs)
+      .join(',')}])`
+  }
+}

package/src/utils.js

@@ -1,13 +1,14 @@
 import std from '../lib/baked/std.js'
 import { comp, OPTIMIZATIONS } from './compiler.js'
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
-import { evaluate, run } from './evaluator.js'
+import { evaluate } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 import {
   deSuggarAst,
   deSuggarSource,
   handleUnbalancedQuotes
 } from './macros.js'
+import { keywords } from './interpreter.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
@@ -212,10 +213,17 @@ export const dfs = (tree, callback) => {
   if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
   else callback(tree)
 }
+export const wrapInBlock = (ast) => [
+  [APPLY, KEYWORDS.CALL_FUNCTION],
+  [
+    [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
+    [[APPLY, KEYWORDS.BLOCK], ...ast]
+  ]
+]
 export const interpret = (ast, keywords) =>
   ast.reduce((_, x) => evaluate(x, keywords), 0)
 export const fez = (source, options = {}) => {
-  const env = Object.create(null)
+  const env = { ...keywords }
   try {
     if (typeof source === 'string') {
       source = deSuggarSource(source)
@@ -225,16 +233,16 @@ export const fez = (source, options = {}) => {
       const code = !options.mutation ? removeMutation(valid) : valid
       if (!code.length && options.throw) throw new Error('Nothing to parse!')
       const parsed = deSuggarAst(LISP.parse(code))
-      const ast = [...treeShake(parsed, std), ...parsed]
+      const ast = wrapInBlock(shake(parsed, std))
       // if (options.check) typeCheck(ast)
       if (options.compile) return comp(ast)
-      return run(ast, env)
+      return evaluate(ast, env)
     } else if (Array.isArray(source)) {
       const ast = !options.mutation
         ? AST.parse(AST.stringify(source).replace(new RegExp(/!/g), 'ǃ'))
         : source
       if (options.compile) return comp(ast)
-      return run(ast, env)
+      return evaluate(ast, env)
     } else {
       throw new Error('Source has to be either a lisp source code or an AST')
     }
@@ -279,7 +287,7 @@ export const decompress = (raw) => {
   return result
 }
 // shake(LISP.parse(removeNoCode(source)), std)
-export const shake = (parsed, std) => [...treeShake(parsed, std), ...parsed]
+export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)
 export const tree = (source, std) =>
   std
     ? shake(LISP.parse(deSuggarSource(removeNoCode(source))), std)
@@ -288,45 +296,20 @@ export const minify = (source) =>
   LISP.source(deSuggarAst(LISP.parse(deSuggarSource(removeNoCode(source)))))
 export const prep = (source) =>
   deSuggarAst(LISP.parse(removeNoCode(deSuggarSource(source))))
-export const src = (source, deps) => {
-  source = prep(source)
-  return LISP.source([
-    ...treeShake(
-      source,
-      deps.reduce((a, b) => a.concat(b), [])
-    ),
-    ...source
-  ])
-}
-export const ast = (source, deps) => {
-  source = prep(source)
-  return [
-    ...treeShake(
-      source,
-      deps.reduce((a, b) => a.concat(b), [])
-    ),
-    ...source
-  ]
-}
-export const astWithStd = (source) => {
-  const parsed = prep(source)
-  return [...treeShake(parsed, std), ...parsed]
-}
-export const dependencies = (source, deps) => {
-  source = prep(source)
-  return shakedList(
-    source,
-    deps.reduce((a, b) => a.concat(b), [])
+export const src = (source, deps) =>
+  LISP.source(
+    wrapInBlock(
+      shake(
+        prep(source),
+        deps.reduce((a, b) => a.concat(b), [])
+      )
+    )
   )
-}
-export const js = (source, deps) => {
-  source = prep(source)
-  const { top, program } = comp([
-    ...treeShake(
-      source,
+export const ast = (source, deps) =>
+  wrapInBlock(
+    shake(
+      prep(source),
       deps.reduce((a, b) => a.concat(b), [])
-    ),
-    ...source
-  ])
-  return `${top}${program}`
-}
+    )
+  )
+export const astWithStd = (source) => wrapInBlock(shake(prep(source), std))