fez-lisp 1.0.0

package/lib/src/std.lisp

@@ -0,0 +1,275 @@
+(let E 2.718281828459045)
+(let PI 3.141592653589793)
+
+(let* iteration (lambda array callback  
+                                (when (length array) 
+                                  (do (callback (car array)) 
+                                      (iteration (cdr array) callback)))))
+
+(let scan (lambda array callback (do
+                  (let* iterate (lambda array out  
+                        (if (length array) 
+                              (iterate (cdr array) 
+                                (merge out (Array (callback (car array)))))
+                              out)))
+                      (iterate array ()))))
+
+(let select (lambda array callback (do
+                  (let* iterate (lambda array out  
+                        (if (length array)
+                            (iterate (cdr array) 
+                                      (if (callback (car array)) 
+                                            (merge out (Array (car array))) 
+                                            out))
+                            out)))
+                      (iterate array ()))))
+
+(let exclude (lambda array callback (do
+                  (let* iterate (lambda array out  
+                        (if (length array)
+                            (iterate (cdr array) 
+                                      (if (not (callback (car array))) 
+                                            (merge out (Array (car array))) 
+                                            out))
+                            out)))
+                      (iterate array ()))))
+                                            
+(let fold (lambda array callback initial (do
+                  (let* iterate (lambda array out  
+                        (if (length array)
+                            (iterate (cdr array) (callback out (car array)))
+                            out)))
+                      (iterate array initial))))
+
+(let every? (lambda array callback (do
+                    (let* iterate (lambda array  
+                          (if (and (length array) (callback (car array))) 
+                              (iterate (cdr array))
+                              (not (length array)))))
+                        (iterate array))))
+
+(let some? (lambda array callback (do
+                    (let* iterate (lambda array  
+                          (if (and (length array) (not (callback (car array)))) 
+                              (iterate (cdr array))
+                              (type (length array) Boolean))))
+                        (iterate array))))
+
+(let find (lambda array callback (do
+                    (let* iterate (lambda array  
+                          (when (length array) 
+                              (if (callback (car array)) (car array) (iterate (cdr array))))))
+                        (iterate array))))
+
+(let has? (lambda array callback (do
+                    (let* iterate (lambda array  
+                          (when (length array) 
+                              (if (callback (car array)) 1 (iterate (cdr array))))))
+                        (iterate array))))
+
+(let reverse (lambda array (do
+                    (let* iterate (lambda array out 
+                          (if (length array) 
+                              (iterate (cdr array) 
+                              (merge (Array (car array)) out)) 
+                          out)))
+                        (iterate array ()))))
+
+(let range (lambda start end (do 
+                          (let* iterate (lambda out count
+                          (if (<= count end) (iterate (merge out (Array count)) (+ count 1)) out)))
+                          (iterate () start))))
+
+(let sequence (lambda array (do 
+                          (let end (length array))
+                          (let* iterate (lambda out count
+                          (if (< (length out) end) (iterate (merge out (Array count)) (+ count 1)) out)))
+                          (iterate () 0))))
+
+(let sequence-n (lambda n (do 
+                          (let* iterate (lambda out count
+                          (if (< (length out) n) (iterate (merge out (Array count)) (+ count 1)) out)))
+                          (iterate () 0))))
+
+(let unique (lambda array (go 
+      (let sorted (sort array (safety lambda a b (> a b)))) 
+      (zip (sequence sorted))
+      (select (lambda x 
+               (or (not (let index (car (cdr x))))
+                  (not (= (get sorted (- index 1)) (get sorted index))))))
+      (scan car))))
+
+(let for-range (lambda start end callback (do 
+                          (let* iterate (lambda i
+                          (when (< i end) 
+                                (do 
+                                  (callback i) 
+                                  (iterate (+ i 1))))))
+                          (iterate start))))
+
+(let list-range (lambda start end (do 
+   (let range (lambda list start end 
+      (if (< start end) 
+         (Array (merge list (range (Array (Array (+ start 1))) (+ start 1) end))) 
+         list)))
+      (car (car (range () start end))))))
+
+(let traverse (lambda x callback 
+    (if (Atom? x) 
+        (callback x) 
+        (iterate x (lambda y (traverse y callback))))))
+
+(let summation (lambda array (fold array (safety lambda a b (+ a b)) 0)))
+(let product (lambda array (fold array (safety lambda a b (* a b)) 1)))
+(let maximum (lambda array (fold array (safety lambda a b (if (> a b) a b)) (car array))))
+(let minimum (lambda array (fold array (safety lambda a b (if (< a b) a b)) (car array))))
+(let max (lambda a b (if (> a b) a b)))
+(let min (lambda a b (if (< a b) a b)))
+(let count-of (lambda array callback (go array (select callback) (length))))
+(let increment (safety lambda i (+ i 1)))
+(let floor (safety lambda n (| n 0)))
+(let round (safety lambda n (| (+ n 0.5) 0)))
+(let empty? (safety lambda array (not (length array))))
+(let array-in-bounds? (safety lambda array index (and (< index (length array)) (>= index 0))))
+
+(let string->array (safety lambda string (type string Array)))
+(let array->string (lambda array (fold array (safety lambda a x (concatenate a (type x String))) "")))
+(let string->number (safety lambda string (type string Number)))
+(let number->string (safety lambda number (type number String)))
+(let strings->numbers (lambda array (scan array (safety lambda x (type x Number)))))
+(let numbers->strings (lambda array (scan array (safety lambda x (type x String)))))
+(let string->charcodes (lambda string (go string (type Array) (scan (lambda x (type x Char-Code))))))
+(let chars->charcodes (lambda array (go array (scan (lambda x (type x Char-Code))))))
+(let charcodes->chars (lambda array (go array (scan (lambda x (type x Char))))))
+(let charcodes->string (lambda array (go array (scan (lambda x (type x Char))) (array->string))))
+
+(let power (lambda base exp 
+  (if (< exp 0) 
+      (if (= base 0) 
+      (throw "Attempting to divide by 0 in (power)")
+      (/ (* base (power base (- (* exp -1) 1))))) 
+        (cond 
+            (= exp 0) 1
+            (= exp 1) base
+            (*) (* base (power base (- exp 1)))))))
+
+(let greatest-common-divisor (lambda a b (do 
+    (let* gcd (lambda a b 
+          (if (= b 0) a (gcd b (mod a b)))) (gcd a b)))))
+
+(let least-common-divisor (lambda a b (* a b (/ (greatest-common-divisor a b)))))
+
+(let sqrt (lambda x (do 
+  (let is-good-enough (lambda g x (< (abs (- (square g) x)) 0.01))
+        improve-guess (lambda g x (average g (* x (/ g)))))
+  (let* sqrt-iter (lambda g x 
+      (if (is-good-enough g x) g
+          (sqrt-iter (improve-guess g x) x))))
+  (sqrt-iter 1.0 x))))
+(let circumference (lambda radius (* PI (* radius 2))))
+(let hypotenuse (lambda a b (sqrt (+ (* a a) (* b b)))))
+(let abs (safety lambda n (- (^ n (>> n 31)) (>> n 31))))
+(let nth-digit (lambda digit n (| (mod (/ digit (power 10 (- n 1))) 10) 0.5)))
+(let normalize (safety lambda value min max (* (- value min) (/ (- max min)))))
+(let linear-interpolation (safety lambda a b n (+ (* (- 1 n) a) (* n b))))
+(let gauss-sum (safety lambda n (* n (+ n 1) 0.5)))
+(let gauss-sum-sequance (safety lambda a b (* (+ a b) (+ (- b a) 1) 0.5)))
+(let clamp (safety lambda x limit (if (> x limit) limit x)))
+(let odd? (safety lambda x (= (mod x 2) 1)))
+(let even? (safety lambda x (= (mod x 2) 0)))
+(let sign (safety lambda n (if (< n 0) -1 1)))
+(let radians (lambda deg (* deg PI (/ 180))))
+(let average (safety lambda x y (* (+ x y) 0.5)))
+(let euclidean-mod (safety lambda a b (mod (+ (mod a b) b) b)))
+(let euclidean-distance (lambda x1 y1 x2 y2 (do
+  (let a (- x1 x2))
+  (let b (- y1 y2))
+  (sqrt (+ (* a a) (* b b))))))
+(let manhattan-distance (lambda x1 y1 x2 y2 (+ (abs (- x2 x1)) (abs (- y2 y1)))))
+(let positive? (safety lambda num (> num 0)))
+(let negative? (safety lambda num (< num 0)))
+(let zero? (safety lambda num (= num 0)))
+(let divisible? (safety lambda a b (= (mod a b) 0)))
+(let prime? (lambda n 
+      (cond 
+        (= n 1) 0
+        (< n 0) 0
+        (*) (do 
+        (let* iter (lambda i end (do 
+            (let it-is (not (= (mod n i) 0)))
+            (if (and (<= i end) it-is) (iter (+ i 1) end) it-is))))
+            (or (= n 2) (iter 2 (sqrt n)))))))
+
+(let slice (safety lambda array start end (do 
+        (let bounds (- end start))
+        (let* iterate (lambda i out
+          (if (< i bounds) 
+              (iterate (+ i 1) (merge out (Array (get array (+ start i)))))
+              out)))
+        (iterate 0 ()))))
+
+(let binary-search
+        (lambda array target (do
+  (let* search
+        (lambda arr target start end (do
+    (when (<= start end) (do
+        (let index (floor (* (+ start end) 0.5)))
+        (let current (get arr index))
+        (if (= target current) target
+          (if (> current target)
+            (search arr target start (- index 1))
+            (search arr target (+ index 1) end))))))))
+   (search array target 0 (length array)))))
+
+(let zip (safety lambda A B (do 
+  (let* iterate (lambda a b output
+    (if (and (length a) (length b)) (iterate (cdr a) (cdr b) (merge output (Array (Array (car a) (car b))))) output)))
+  (iterate A B ()))))
+
+(let cartesian-product (lambda a b (fold a (lambda p x (merge p (scan b (lambda y (Array x y))))) ())))
+
+(let equal? (lambda a b 
+  (or (and (Atom? a) (Atom? b) (= a b)) 
+  (and (Array? a) 
+        (= (length a) (length b)) 
+          (not (some? (sequence a) (lambda i (not (equal? (get a i) (get b i))))))))))
+
+(let split (lambda string delim (do 
+    (let input (type (concatenate string delim) Array))
+    (let marks 
+    (go 
+      input
+      (zip (sequence input)) 
+      (scan (lambda x (if (= (car x) delim) (car (cdr x)) (car x))))))
+    (let first (find marks (lambda x (Number? x))))
+  (go 
+    marks
+    (fold (lambda a b 
+      (if (Number? b)
+      (merge a (Array (slice input (- b first) b)))
+      a)) ())
+    (scan (lambda x (array->string x)))))))
+
+(let join (lambda array delim (fold (zip array (sequence array)) (lambda a b (if (> (car (cdr b)) 0) (concatenate a delim (type (car b) String)) (type (car b) String))) "")))
+
+(let flat (lambda array (do
+  (let flatten (lambda item 
+    (if (and (Array? item) (length item))
+        (fold item (lambda a b (merge a (flatten b))) ())
+        (Array item))))
+  (flatten array))))
+
+  (let sort (lambda arr callback (do
+    (if (<= (length arr) 1) arr (do
+      (let pivot (car arr))
+      (let* iterate (lambda i bounds a b (do
+          (let current (get arr i))
+          (let predicate (callback current pivot))
+          (let left (if (= predicate 0) (merge a (Array current)) a))
+          (let right (if (= predicate 1) (merge b (Array current)) b))
+          (if (< i bounds) (iterate (+ i 1) bounds left right)
+          (Array left right)))))
+      (let sorted (iterate 1 (- (length arr) 1) () ()))
+      (let left (car sorted))
+      (let right (car (cdr sorted)))
+      (merge (sort left callback) (Array pivot) (sort right callback)))))))

package/logo.svg

@@ -0,0 +1,8 @@
+<svg width="144" height="128" viewBox="0 0 144 128" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M128 0H0V128H128V0Z" fill="#B44637"/>
+<path d="M128 0H0V128H128V0Z" fill="#B44637"/>
+<path d="M128 0H96V128H128V0Z" fill="#8E2F22"/>
+<path d="M128 0H96V128H128V0Z" fill="#8E2F22"/>
+<path d="M112 0H128V64H112V0Z" fill="#D6C096"/>
+<path d="M128 64H144V80H128V64Z" fill="#D6C096"/>
+</svg>

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "fez-lisp",
+  "description": "Immutable Lisp interpreted & compiled to JavaScript",
+  "author": "AT290690",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "keywords": [
+    "lisp",
+    "expressions",
+    "programming-language",
+    "interpreter",
+    "compiler"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AT-290690/fez.git"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true
+  },
+  "scripts": {
+    "build": "node ./lib/builder.js",
+    "fez": "node main.js",
+    "test": "mocha"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "mocha": "^10.2.0"
+  },
+  "dependencies": {}
+}

package/src/compiler.js

@@ -0,0 +1,361 @@
+import {
+  APPLY,
+  ATOM,
+  PLACEHOLDER,
+  KEYWORDS,
+  TYPE,
+  VALUE,
+  WORD,
+} from './enums.js'
+import { deepRename, lispToJavaScriptVariableName } from './utils.js'
+const Helpers = {
+  log: `var logEffect=(msg)=>{console.log(msg);return msg}`,
+  _merge: `_merge=(...arrays)=>arrays.reduce((a,b)=>a.concat(b),[])`,
+  tco: `tco=fn=>(...args)=>{
+let result=fn(...args)
+while(typeof result==='function')result=result()
+return result
+  }`,
+  atom: `_isAtom=(value)=>typeof value==='number'||typeof value==='string'`,
+  error: `_error=(error)=>{ 
+    throw new Error(error)
+}`,
+  serialise: `_serialise=(result)=>{
+    return typeof result==='function'?'(λ)':Array.isArray(result)?JSON.stringify(result,(_,value)=>{
+          switch(typeof value){
+            case 'number':
+              return Number(value)
+            case 'function':
+              return 'λ'
+            case 'undefined':
+            case 'symbol':
+              return 0
+            case 'boolean':
+              return +value
+            default:
+              return value
+          }
+        })
+          .replace(new RegExp(/\\[/g),"(Array ")
+          .replace(new RegExp(/\\]/g),')')
+          .replace(new RegExp(/\\,/g),' ')
+          .replace(new RegExp(/"λ"/g),'λ')
+      :typeof result==='string'
+      ?'"'+result+'"'
+      :result==undefined
+      ?'(void)'
+      :result 
+  }`,
+  cast: `_cast=(type,value)=>{
+    switch (type) {
+      case 'Number':
+         return Number(value)
+      case 'String':
+         return value.toString()
+      case 'Array':
+        return typeof value==='number'?[...Number(value).toString()].map(Number):[...value]
+      case 'Bit':
+         return parseInt(value,2)
+      case 'Boolean':
+          return +!!value
+      case 'Function':
+          return ()=>value
+      case 'Char-Code':
+        return String.fromCharCode(value)
+      case 'Char':
+        return value.charCodeAt(0)
+       default:
+         return 0
+      }
+    }`,
+}
+const handleBoolean = (source) => `+${source}`
+const semiColumnEdgeCases = new Set([
+  ';)',
+  ';-',
+  ';+',
+  ';*',
+  ';%',
+  ';&',
+  ';/',
+  ';:',
+  ';.',
+  ';=',
+  ';<',
+  ';>',
+  ';|',
+  ';,',
+  ';?',
+  ',,',
+  ';;',
+  ';]',
+])
+
+const parse = (Arguments, Variables) =>
+  Arguments.map((x) => compile(x, Variables))
+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]
+  if (first == undefined) return '[];'
+  const token = first[VALUE]
+  if (first[TYPE] === APPLY) {
+    switch (token) {
+      case KEYWORDS.BLOCK: {
+        if (Arguments.length > 1) {
+          return `(${Arguments.map((x) =>
+            (compile(x, Variables) ?? '').toString().trimStart()
+          )
+            .filter(Boolean)
+            .join(',')});`
+        } else {
+          const res = compile(Arguments[0], Variables)
+          return res !== undefined ? res.toString().trim() : ''
+        }
+      }
+      case KEYWORDS.CALL_FUNCTION: {
+        const [first, ...rest] = Arguments
+        const apply = compile(first, Variables)
+        return `${
+          apply[apply.length - 1] === ';'
+            ? apply.substring(0, apply.length - 1)
+            : apply
+        }(${parseArgs(rest, Variables)})`
+      }
+      case KEYWORDS.DEFINE_VARIABLE: {
+        let name,
+          out = '(('
+        if (Arguments[0][TYPE] === WORD) {
+          name = lispToJavaScriptVariableName(Arguments[0][VALUE])
+          Variables.add(name)
+        }
+        out += `${name}=${compile(Arguments[1], Variables)}`
+        out += `),${name});`
+        return out
+      }
+      case KEYWORDS.IS_STRING:
+        return handleBoolean(
+          `(typeof(${compile(Arguments[0], Variables)})==='string');`
+        )
+      case KEYWORDS.IS_NUMBER:
+        return handleBoolean(
+          `(typeof(${compile(Arguments[0], Variables)})==='number');`
+        )
+      case KEYWORDS.IS_FUNCTION:
+        return `(typeof(${compile(Arguments[0], Variables)})==='function');`
+      case KEYWORDS.IS_ARRAY:
+        return `(Array.isArray(${compile(Arguments[0], Variables)}));`
+      case KEYWORDS.NUMBER_TYPE:
+        return '0'
+      case KEYWORDS.INTEGER_TYPE:
+        return '0n'
+      case KEYWORDS.BOOLEAN_TYPE:
+        return '1'
+      case KEYWORDS.STRING_TYPE:
+        return '""'
+      case KEYWORDS.ARRAY_TYPE:
+        return Arguments.length === 2 &&
+          Arguments[1][TYPE] === WORD &&
+          Arguments[1][VALUE] === 'length'
+          ? `(new Array(${compile(Arguments[0], Variables)}).fill(0))`
+          : `[${parseArgs(Arguments, Variables)}];`
+      case KEYWORDS.FUNCTION_TYPE:
+        return '(()=>{});'
+      case KEYWORDS.ARRAY_OR_STRING_LENGTH:
+        return `(${compile(Arguments[0], Variables)}).length`
+      case KEYWORDS.IS_ATOM:
+        return handleBoolean(`_isAtom(${compile(Arguments[0], Variables)});`)
+      case KEYWORDS.FIRST_ARRAY:
+        return `${compile(Arguments[0], Variables)}.at(0);`
+      case KEYWORDS.REST_ARRAY:
+        return `${compile(Arguments[0], Variables)}.slice(1);`
+      case KEYWORDS.GET_ARRAY:
+        return `${compile(Arguments[0], Variables)}.at(${compile(
+          Arguments[1],
+          Variables
+        )});`
+      case KEYWORDS.MERGE:
+        return `_merge(${parseArgs(Arguments, Variables)});`
+      case KEYWORDS.ANONYMOUS_FUNCTION: {
+        const functionArgs = Arguments
+        const body = Arguments.pop()
+        const Variables = new Set()
+        const evaluatedBody = compile(body, Variables)
+        const vars = Variables.size ? `var ${[...Variables].join(',')};` : ''
+        return `((${parseArgs(
+          functionArgs.map((node, index) =>
+            node[VALUE] === PLACEHOLDER
+              ? { [TYPE]: node[TYPE], [VALUE]: `_${index}` }
+              : { [TYPE]: node[TYPE], [VALUE]: node[VALUE] }
+          ),
+          Variables
+        )})=>{${vars}return ${evaluatedBody.toString().trimStart()}});`
+      }
+      case KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION: {
+        let name,
+          newName,
+          out = '(('
+        const arg = Arguments[0]
+        name = lispToJavaScriptVariableName(arg[VALUE])
+        newName = `rec_${performance.now().toString().replace('.', 7)}`
+        Variables.add(name)
+        Variables.add(newName)
+        const functionArgs = Arguments[1].slice(1)
+        const body = functionArgs.pop()
+        const FunctionVariables = new Set()
+        deepRename(arg[VALUE], newName, body)
+        const evaluatedBody = compile(body, FunctionVariables)
+        const vars = FunctionVariables.size
+          ? `var ${[...FunctionVariables].join(',')};`
+          : ''
+        out += `${name}=(tco(${newName}=(${parseArgs(
+          functionArgs,
+          Variables
+        )})=>{${vars}return ${evaluatedBody.toString().trimStart()}};`
+        out += `, ${newName}))), ${name});`
+        return out
+      }
+      case KEYWORDS.AND:
+        return `(${parseArgs(Arguments, Variables, '&&')});`
+      case KEYWORDS.OR:
+        return `((${parseArgs(Arguments, Variables, '||')}) || 0);`
+      case KEYWORDS.CONCATENATION:
+        return '(' + parseArgs(Arguments, Variables, '+') + ');'
+      case KEYWORDS.EQUAL:
+        return handleBoolean(`(${parseArgs(Arguments, Variables, '===')});`)
+      case KEYWORDS.GREATHER_THAN_OR_EQUAL:
+      case KEYWORDS.LESS_THAN_OR_EQUAL:
+      case KEYWORDS.GREATHER_THAN:
+      case KEYWORDS.LESS_THAN:
+        return handleBoolean(`(${parseArgs(Arguments, Variables, token)});`)
+      case KEYWORDS.SUBTRACTION:
+        return Arguments.length === 1
+          ? `(-${compile(Arguments[0], Variables)});`
+          : `(${parse(Arguments, Variables)
+              // Add space so it doesn't consider it 2--1 but 2- -1
+              .map((x) => (typeof x === 'number' && x < 0 ? ` ${x}` : x))
+              .join(token)});`
+      case KEYWORDS.MULTIPLICATION:
+        return Arguments.length
+          ? `(${parseArgs(Arguments, Variables, token)});`
+          : `(1);`
+      case KEYWORDS.DIVISION:
+        return Arguments.length
+          ? Arguments.length === 1
+            ? `(1/${compile(Arguments[0], Variables)});`
+            : `(${parseArgs(Arguments, Variables, token)});`
+          : `(0);`
+      case KEYWORDS.ADDITION:
+      case KEYWORDS.BITWISE_AND:
+      case KEYWORDS.BITWISE_OR:
+      case KEYWORDS.BITWISE_XOR:
+      case KEYWORDS.BITWISE_LEFT_SHIFT:
+      case KEYWORDS.BITWISE_RIGHT_SHIFT:
+      case KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT:
+        return `(${parseArgs(Arguments, Variables, token)});`
+      case KEYWORDS.REMAINDER_OF_DIVISION:
+        return `(${compile(Arguments[0], Variables)}%${compile(
+          Arguments[1],
+          Variables
+        )});`
+      case KEYWORDS.BIT_TYPE:
+        return `(${compile(Arguments[0], Variables)}>>>0).toString(2)`
+      case KEYWORDS.BITWISE_NOT:
+        return `~(${compile(Arguments[0], Variables)})`
+      case KEYWORDS.NOT:
+        return `(${handleBoolean(`!${compile(Arguments[0], Variables)}`)})`
+      case KEYWORDS.IF: {
+        return `(${compile(Arguments[0], Variables)}?${compile(
+          Arguments[1],
+          Variables
+        )}:${compile(Arguments[2], Variables)});`
+      }
+      case KEYWORDS.WHEN: {
+        return `(${compile(Arguments[0], Variables)}?${compile(
+          Arguments[1],
+          Variables
+        )}:0);`
+      }
+      case KEYWORDS.UNLESS: {
+        return `(${compile(Arguments[0], Variables)}?${compile(
+          Arguments[2],
+          Variables
+        )}:${compile(Arguments[1], Variables)});`
+      }
+      case KEYWORDS.OTHERWISE: {
+        return `(${compile(Arguments[0], Variables)}?0:${compile(
+          Arguments[1],
+          Variables
+        )});`
+      }
+      case KEYWORDS.CONDITION: {
+        let out = '('
+        for (let i = 0; i < Arguments.length; i += 2)
+          out += `${compile(Arguments[i], Variables)}?${compile(
+            Arguments[i + 1],
+            Variables
+          )}:`
+        out += '0);'
+        return out
+      }
+      case KEYWORDS.CAST_TYPE:
+        return `_cast("${Arguments[1][VALUE]}", ${compile(
+          Arguments[0],
+          Variables
+        )})`
+      case KEYWORDS.PIPE: {
+        let inp = Arguments[0]
+        for (let i = 1; i < Arguments.length; ++i)
+          inp = [Arguments[i].shift(), inp, ...Arguments[i]]
+        return compile(inp, Variables)
+      }
+      case KEYWORDS.THROW_ERROR: {
+        return `_error(${compile(Arguments[0], Variables)})`
+      }
+      case KEYWORDS.IMMUTABLE_FUNCTION: {
+        const [first, ...rest] = Arguments
+        return compile(
+          [{ [TYPE]: APPLY, [VALUE]: first[VALUE] }, ...rest],
+          Variables
+        )
+      }
+      case KEYWORDS.SERIALISE:
+        return `_serialise(${compile(Arguments[0], Variables)});`
+      case KEYWORDS.NOT_COMPILED_BLOCK:
+      case KEYWORDS.ATOM:
+      case KEYWORDS.TEST_CASE:
+      case KEYWORDS.TEST_BED:
+        return ''
+      default: {
+        const camelCased = lispToJavaScriptVariableName(token)
+        return `${camelCased}(${parseArgs(Arguments, Variables)});`
+      }
+    }
+  } else if (first[TYPE] === ATOM)
+    return typeof first[VALUE] === 'string'
+      ? `\`${first[VALUE]}\``
+      : first[VALUE]
+  else if (first[TYPE] === WORD) return lispToJavaScriptVariableName(token)
+}
+
+const HelperSources = Object.values(Helpers).join(',')
+
+export const comp = (ast) => {
+  const Variables = new Set()
+  const raw = ast
+    .map((tree) => compile(tree, Variables))
+    .filter(Boolean)
+    .join('\n')
+  let program = ''
+  for (let i = 0; i < raw.length; ++i) {
+    const current = raw[i]
+    const next = raw[i + 1]
+    if (!semiColumnEdgeCases.has(current + next)) program += current
+  }
+  const top = `${HelperSources};\n${
+    Variables.size ? `var ${[...Variables].join(',')};` : ''
+  }`
+
+  return { top, program }
+}