fez-lisp 1.1.10 → 1.1.12

package/package.json

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

package/src/compiler.js

@@ -66,7 +66,6 @@ const lispToJavaScriptVariableName = (name) =>
     )
   )
 const Helpers = {
-  __string: `__string=(...args)=>{const str=args.flat();str.isString=true;return str}`,
   __add: `__add=(...numbers)=>{return numbers.reduce((a,b)=>a+b,0)}`,
   __sub: `__sub=(...numbers)=>{return numbers.reduce((a,b)=>a-b,0)}`,
   __mult: `__mult=(...numbers)=>{return numbers.reduce((a,b)=>a*b,1)}`,
@@ -81,20 +80,21 @@ const Helpers = {
     for(let i=0; i<args.length-1;++i){
       circuit=args[i]
       if(circuit) continue
-      else return circuit
+      else return 0
     }
-    return args.at(-1) 
+    return args.at(-1) ? 1 : 0
   }`,
   or: `or=(...args)=>{
     let circuit;
     for(let i=0;i<args.length-1;++i) {
       circuit = args[i]
-      if(circuit)return circuit
+      if(circuit) return 1
       else continue
     }
-    return args.at(-1) 
+    return args.at(-1) ? 1 : 0
   }`,
   logEffect: `logEffect=(msg)=>{console.log(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)`,
   car: 'car=(arr)=>arr.at(0)',
@@ -105,7 +105,6 @@ const Helpers = {
   numberPredicate: `numberPredicate=(number)=>+(typeof number==='number')`,
   lambdaPredicate: `lambdaPredicate=(lambda)=>+(typeof lambda==='function')`,
   arrayPredicate: `arrayPredicate=(array)=>+Array.isArray(array)`,
-  error: `error=(error)=>{throw new Error(error)}`,
   array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
 }
 const semiColumnEdgeCases = new Set([
@@ -260,9 +259,9 @@ const compile = (tree, Drill) => {
           )
       }
       case KEYWORDS.AND:
-        return `(${parseArgs(Arguments, Drill, '&&')});`
+        return `((${parseArgs(Arguments, Drill, '&&')}) ? 1 : 0);`
       case KEYWORDS.OR:
-        return `((${parseArgs(Arguments, Drill, '||')}) || 0);`
+        return `((${parseArgs(Arguments, Drill, '||')}) ? 1 : 0);`
       case KEYWORDS.EQUAL:
         return `+(${parseArgs(Arguments, Drill, '===')});`
       case KEYWORDS.GREATHER_THAN_OR_EQUAL:

package/src/interpreter.js

@@ -197,11 +197,6 @@ const keywords = {
       if (evaluate(args[i], env)) return evaluate(args[i + 1], env)
     return 0
   },
-  [KEYWORDS.STRING_TYPE]: (args, env) => {
-    const str = args.flatMap((x) => evaluate(x, env))
-    str.isString = true
-    return str
-  },
   [KEYWORDS.ARRAY_TYPE]: (args, env) => {
     if (!args.length) return []
     const isCapacity =
@@ -499,9 +494,9 @@ const keywords = {
     for (let i = 0; i < args.length - 1; ++i) {
       circuit = evaluate(args[i], env)
       if (circuit) continue
-      else return circuit
+      else return 0
     }
-    return evaluate(args.at(-1), env)
+    return evaluate(args.at(-1), env) ? 1 : 0
   },
   [KEYWORDS.OR]: (args, env) => {
     if (args.length < 2)
@@ -513,10 +508,10 @@ const keywords = {
     let circuit
     for (let i = 0; i < args.length - 1; ++i) {
       circuit = evaluate(args[i], env)
-      if (circuit) return circuit
+      if (circuit) return 1
       else continue
     }
-    return evaluate(args.at(-1), env)
+    return evaluate(args.at(-1), env) ? 1 : 0
   },
   [KEYWORDS.CALL_FUNCTION]: (args, env) => {
     if (!args.length)
@@ -906,15 +901,26 @@ const keywords = {
     return array
   },
   [KEYWORDS.LOG]: (args, env) => {
-    if (!args.length)
+    if (args.length !== 1)
       throw new RangeError(
-        `Invalid number of arguments to (${KEYWORDS.LOG}) (>= 1 required) (${
+        `Invalid number of arguments to (${KEYWORDS.LOG}) (= 1 required) (${
           KEYWORDS.LOG
         } ${stringifyArgs(args)})`
       )
-    const expressions = args.map((x) => evaluate(x, env))
-    console.log(...expressions)
-    return expressions.at(-1)
+    const expression = evaluate(args[0], env)
+    console.log(expression)
+    return expression
+  },
+  [KEYWORDS.LOG_STRING]: (args, env) => {
+    if (args.length !== 1)
+      throw new RangeError(
+        `Invalid number of arguments to (${
+          KEYWORDS.LOG_STRING
+        }) (= 1 required) (${KEYWORDS.LOG_STRING} ${stringifyArgs(args)})`
+      )
+    const expression = evaluate(args[0], env)
+    console.log(expression.map((x) => String.fromCharCode(x)).join(''))
+    return expression
   },
   [KEYWORDS.CLEAR_CONSOLE]: (args) => {
     if (args.length)

package/src/keywords.js

@@ -6,7 +6,6 @@ export const ATOM = 2
 export const PLACEHOLDER = '.'
 export const KEYWORDS = {
   NUMBER_TYPE: 'number',
-  STRING_TYPE: 'string',
   ARRAY_TYPE: 'array',
   ARRAY_LENGTH: 'length',
   IS_ARRAY: 'array?',
@@ -50,6 +49,7 @@ export const KEYWORDS = {
   TEST_CASE: 'case',
   TEST_BED: 'assert',
   LOG: 'log!',
+  LOG_STRING: 'log-string!',
   CLEAR_CONSOLE: 'clear!',
   SET_ARRAY: 'array:set!',
   DOC: 'fez-manual'

package/src/utils.js

@@ -1,7 +1,5 @@
 import std from '../lib/baked/std.js'
-import { comp as JavaScript } from './compiler.js'
-import { comp as OCaml } from './ocaml.js'
-
+import { comp } from './compiler.js'
 import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
 import { run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
@@ -14,7 +12,7 @@ export const replaceStrings = (source) => {
     for (const q of quotes)
       source = source.replaceAll(
         q,
-        `(string ${[...q]
+        `(array ${[...q]
           .slice(1, -1)
           .map((x) => x.charCodeAt(0))
           .join(' ')})`
@@ -136,7 +134,7 @@ export const handleUnbalancedQuotes = (source) => {
 }
 export const removeMutation = (source) => source.replace(new RegExp(/!/g), 'ǃ')
 export const treeShake = (ast, libs) => {
-  const deps = libs.reduce((a, x) => a.add(x.at(1)[VALUE]), new Set())
+  const deps = libs.reduce((a, x) => a.set(x.at(1)[VALUE], x), new Map())
   const visited = new Set()
   const dfs = (tree) => {
     if (!isLeaf(tree)) tree.forEach(dfs)
@@ -147,13 +145,14 @@ export const treeShake = (ast, libs) => {
     ) {
       visited.add(tree[VALUE])
       // Recursively explore the dependencies of the current node
-      const dependency = libs.find((x) => x.at(1)[VALUE] === tree[VALUE])
+      const dependency = deps.get(tree[VALUE])
       if (dependency) dfs(dependency.at(-1))
     }
   }
   dfs(ast)
   // Filter out libraries that are not in the visited set
-  return libs.filter((x) => visited.has(x.at(1)[VALUE]))
+  // return libs.filter((x) => visited.has(x.at(1)[VALUE]))
+  return [...visited].reverse().map((x) => deps.get(x))
 }
 export const dfs = (tree, callback) => {
   if (!isLeaf(tree)) for (const leaf of tree) dfs(leaf)
@@ -180,16 +179,8 @@ export const fez = (source, options = {}) => {
         )
       const ast = [...treeShake(parsed, std), ...parsed]
       if (options.compile) {
-        switch (options.compile) {
-          case 1: {
-            const js = Object.values(JavaScript(deepClone(ast))).join('')
-            return options.eval ? eval(js) : js
-          }
-          case 2: {
-            const oCaml = Object.values(OCaml(deepClone(ast))).join('')
-            return oCaml
-          }
-        }
+        const js = Object.values(comp(deepClone(ast))).join('')
+        return options.eval ? eval(js) : js
       }
       return run(ast, env)
     } else if (Array.isArray(source)) {
@@ -197,16 +188,8 @@ export const fez = (source, options = {}) => {
         ? AST.parse(AST.stringify(source).replace(new RegExp(/!/g), 'ǃ'))
         : source
       if (options.compile) {
-        switch (options.compile) {
-          case 1: {
-            const js = Object.values(JavaScript(deepClone(ast))).join('')
-            return options.eval ? eval(js) : js
-          }
-          case 2: {
-            const OCaml = Object.values(OCaml(deepClone(ast))).join('')
-            return OCaml
-          }
-        }
+        const js = Object.values(comp(deepClone(ast))).join('')
+        return options.eval ? eval(js) : js
       }
       return run(ast, env)
     } else {

package/src/ocaml.js

@@ -1,373 +0,0 @@
-import {
-  APPLY,
-  ATOM,
-  PLACEHOLDER,
-  KEYWORDS,
-  TYPE,
-  VALUE,
-  WORD
-} from './keywords.js'
-import { leaf, isLeaf } from './parser.js'
-import { deepRename } from './utils.js'
-const earMuffsToLodashes = (name) => name.replace(new RegExp(/\*/g), '_')
-const dotNamesToEmpty = (name) => name.replace(new RegExp(/\./g), '')
-const commaToLodash = (name) => name.replace(new RegExp(/\,/g), '_')
-const arrowFromTo = (name) => name.replace(new RegExp(/->/g), '-to-')
-const moduleNameToLodashes = (name) => name.replace(new RegExp(/:/g), '_')
-const questionMarkToPredicate = (name) =>
-  name.replace(new RegExp(/\?/g), 'Predicate')
-const exclamationMarkMarkToEffect = (name) =>
-  name.replace(new RegExp(/\!/g), 'Effect')
-const toCamelCase = (name) => {
-  let out = name[0]
-  for (let i = 1; i < name.length; ++i) {
-    const current = name[i],
-      prev = name[i - 1]
-    if (current === '-') continue
-    else if (prev === '-') out += current.toUpperCase()
-    else out += current
-  }
-  return out
-}
-const keywordToHelper = (name) => {
-  switch (name) {
-    case KEYWORDS.ADDITION:
-      return '__add'
-    case KEYWORDS.MULTIPLICATION:
-      return '__mult'
-    case KEYWORDS.SUBTRACTION:
-      return '__sub'
-    case KEYWORDS.GREATHER_THAN:
-      return '__gt'
-    case KEYWORDS.EQUAL:
-      return '__eq'
-    case KEYWORDS.GREATHER_THAN_OR_EQUAL:
-      return '__gteq'
-    case KEYWORDS.LESS_THAN:
-      return '__lt'
-    case KEYWORDS.LESS_THAN_OR_EQUAL:
-      return '__lteq'
-    default:
-      return name
-  }
-}
-const lispToJavaScriptVariableName = (name) =>
-  toCamelCase(
-    arrowFromTo(
-      dotNamesToEmpty(
-        exclamationMarkMarkToEffect(
-          questionMarkToPredicate(
-            commaToLodash(
-              moduleNameToLodashes(earMuffsToLodashes(keywordToHelper(name)))
-            )
-          )
-        )
-      )
-    )
-  )
-const Helpers = {
-  // __string: `__string=(...args)=>{const str=args.flat();str.isString=true;return str}`,
-  // __add: `__add=(...numbers)=>{return numbers.reduce((a,b)=>a+b,0)}`,
-  // __sub: `__sub=(...numbers)=>{return numbers.reduce((a,b)=>a-b,0)}`,
-  // __mult: `__mult=(...numbers)=>{return numbers.reduce((a,b)=>a*b,1)}`,
-  // __gteq: '__gteq=(a,b)=>+(a>=b)',
-  // __gt: '__gt=(a,b)=>+(a>b)',
-  // __eq: '__eq=(a,b)=>+(a===b)',
-  // __lteq: '__lteq=(a,b)=>+(a<=b)',
-  // __lt: '__lt=(a,b)=>+(a<b)',
-  // not: 'not=(a)=>+!a',
-  // and: `and=(...args)=>{
-  //   let circuit;
-  //   for(let i=0; i<args.length-1;++i){
-  //     circuit=args[i]
-  //     if(circuit) continue
-  //     else return circuit
-  //   }
-  //   return args.at(-1)
-  // }`,
-  // or: `or=(...args)=>{
-  //   let circuit;
-  //   for(let i=0;i<args.length-1;++i) {
-  //     circuit = args[i]
-  //     if(circuit)return circuit
-  //     else continue
-  //   }
-  //   return args.at(-1)
-  // }`,
-  // logEffect: `logEffect=(msg)=>{console.log(msg);return msg}`,
-  // clearEffect: `clearEffect=()=>{console.clear();return 0}`,
-  array_cons: `rec array_cons lists =
-  match lists with
-  | [] -> []
-  | hd::tl -> hd @ array_cons tl`,
-  car: 'car = fun (arr::_) -> arr',
-  cdr: 'cdr = fun (_::arr) -> arr',
-  array_get: `rec array_get = function
-  | [], _ -> raise (Failure "array_get")
-  | list, n when n < 0 -> array_get(list, List.length(list) - n)
-  | x::_, 0 -> x
-  | x::xs, n -> array_get(xs, n - 1)`,
-  length: 'length(arr)=float_of_int(List.length(arr))'
-  // numberPredicate: `numberPredicate=(number)=>+(typeof number==='number')`,
-  // lambdaPredicate: `lambdaPredicate=(lambda)=>+(typeof lambda==='function')`,
-  // arrayPredicate: `arrayPredicate=(array)=>+Array.isArray(array)`,
-  // error: `error=(error)=>{throw new Error(error)}`,
-  // array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
-  // array_setEffect: `array_setEffect=(array,index,value)=>{if(index<0){const target=array.length+index;while(array.length!==target)array.pop()}else array[index] = value;return array}`
-}
-const semiColumnEdgeCases = new Set([
-  ';)',
-  ';-',
-  ';+',
-  ';*',
-  ';%',
-  ';&',
-  ';/',
-  ';:',
-  ';.',
-  ';=',
-  ';<',
-  ';>',
-  ';|',
-  ';,',
-  ';?',
-  ',,',
-  // ';;',
-  ';]'
-])
-const parse = (Arguments, Drill) => Arguments.map((x) => compile(x, Drill))
-const parseArgs = (Arguments, Drill, separator = ',') =>
-  parse(Arguments, Drill).join(separator)
-const compile = (tree, Drill) => {
-  if (!tree) return ''
-  const [first, ...Arguments] = !isLeaf(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, Drill) ?? '').toString().trimStart().replace(';;', '')
-          )
-            .filter(Boolean)
-            .join(' in\n')})`
-        } else {
-          const res = compile(Arguments[0], Drill)
-          return res !== undefined ? res.toString().trim() : ''
-        }
-      }
-      case KEYWORDS.CALL_FUNCTION: {
-        const [first, ...rest] = Arguments
-        const apply = compile(first, Drill)
-        return `${
-          apply[apply.length - 1] === ';'
-            ? apply.substring(0, apply.length - 1)
-            : apply
-        }(${parseArgs(rest, Drill)})`
-      }
-      case KEYWORDS.DEFINE_VARIABLE: {
-        let name,
-          out = 'let '
-        if (Arguments[0][TYPE] === WORD) {
-          name = lispToJavaScriptVariableName(Arguments[0][VALUE])
-          Drill.Variables.add(name)
-        }
-        out += `${name} = ${compile(Arguments[1], Drill)}`
-        out += `;;`
-        return out
-      }
-      case KEYWORDS.IS_NUMBER:
-        Drill.Helpers.add('numberPredicate')
-        return `numberPredicate(${compile(Arguments[0], Drill)});`
-      case KEYWORDS.IS_FUNCTION:
-        Drill.Helpers.add('lambdaPredicate')
-        return `lambdaPredicate(${compile(Arguments[0], Drill)});`
-      case KEYWORDS.IS_ARRAY:
-        Drill.Helpers.add('arrayPredicate')
-        return `arrayPredicate(${compile(Arguments[0], Drill)});`
-      case KEYWORDS.NUMBER_TYPE:
-        return '0'
-      case KEYWORDS.BOOLEAN_TYPE:
-        return '1'
-      case KEYWORDS.STRING_TYPE:
-        Drill.Helpers.add('__string')
-        return `__string(${parseArgs(Arguments, Drill)});`
-      case KEYWORDS.ARRAY_TYPE:
-        return Arguments.length === 2 &&
-          Arguments[1][TYPE] === WORD &&
-          Arguments[1][VALUE] === 'length'
-          ? `(List.make ${compile(Arguments[0], Drill)} 0)`
-          : `[${parseArgs(Arguments, Drill, ';')}]`
-      case KEYWORDS.ARRAY_LENGTH:
-        Drill.Helpers.add('length')
-        return `length(${compile(Arguments[0], Drill)})`
-      case KEYWORDS.FIRST_ARRAY:
-        Drill.Helpers.add('car')
-        return `car(${compile(Arguments[0], Drill)})`
-      case KEYWORDS.REST_ARRAY:
-        Drill.Helpers.add('cdr')
-        return `cdr(${compile(Arguments[0], Drill)})`
-      case KEYWORDS.GET_ARRAY:
-        Drill.Helpers.add('array_get')
-        return `array_get(${compile(
-          Arguments[0],
-          Drill
-        )}, int_of_float(${compile(Arguments[1], Drill)}))`
-      case KEYWORDS.CONS:
-        Drill.Helpers.add('array_cons')
-        return `array_cons[${parseArgs(Arguments, Drill, ';')}]`
-      case KEYWORDS.ANONYMOUS_FUNCTION: {
-        const functionArgs = Arguments
-        const body = Arguments.pop()
-        const InnerDrills = { Variables: new Set(), Helpers: Drill.Helpers }
-        const evaluatedBody = compile(body, InnerDrills)
-        // const vars = InnerDrills.Variables.size
-        //   ? `let ${[...InnerDrills.Variables].join(',')};`
-        //   : ''
-        return `(fun (${parseArgs(
-          functionArgs.map((node, index) =>
-            node[VALUE] === PLACEHOLDER
-              ? leaf(node[TYPE], `_${index}`)
-              : leaf(node[TYPE], node[VALUE])
-          ),
-          InnerDrills
-        )}) -> ${evaluatedBody.toString().trimStart()})`
-      }
-      case KEYWORDS.TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION: {
-        const arg = Arguments[0]
-        const val = Arguments[1]
-        if (val[0][0] === APPLY && val[0][1] === KEYWORDS.ANONYMOUS_FUNCTION) {
-          const name = lispToJavaScriptVariableName(arg[VALUE])
-          const functionArgs = val.slice(1)
-          const body = functionArgs.pop()
-          const FunctionDrill = { Variables: new Set(), Helpers: Drill.Helpers }
-          const evaluatedBody = compile(body, FunctionDrill)
-          return `let rec ${name} (${parseArgs(
-            functionArgs.map((node, index) =>
-              node[VALUE] === PLACEHOLDER
-                ? leaf(node[TYPE], `_${index}`)
-                : leaf(node[TYPE], node[VALUE])
-            )
-          )}) = ${evaluatedBody.toString().trimStart()};;`
-        }
-      }
-      case KEYWORDS.AND:
-        return `(${parseArgs(Arguments, Drill, '&&')})`
-      case KEYWORDS.OR:
-        return `((${parseArgs(Arguments, Drill, '||')}) || 0.0)`
-      case KEYWORDS.EQUAL:
-        return `(if ${parseArgs(Arguments, Drill, '==')} then 1.0 else 0.0)`
-      case KEYWORDS.GREATHER_THAN_OR_EQUAL:
-      case KEYWORDS.LESS_THAN_OR_EQUAL:
-      case KEYWORDS.GREATHER_THAN:
-      case KEYWORDS.LESS_THAN:
-        return `(if ${parseArgs(Arguments, Drill, token)} then 1.0 else 0.0)`
-      case KEYWORDS.SUBTRACTION:
-        return Arguments.length === 1
-          ? `(-.${compile(Arguments[0], Drill)})`
-          : `(${parse(Arguments, Drill)
-              // 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, Drill, `${token}.`)})`
-          : `(1.0)`
-      case KEYWORDS.DIVISION:
-        return Arguments.length
-          ? Arguments.length === 1
-            ? `(1.0/.${compile(Arguments[0], Drill)})`
-            : `(${parseArgs(Arguments, Drill, `${token}.`)})`
-          : `(0.0)`
-      case KEYWORDS.ADDITION:
-        return Arguments.length
-          ? `(${parseArgs(Arguments, Drill, `${token}.`)})`
-          : `(0.0)`
-      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, Drill, token)})`
-      case KEYWORDS.REMAINDER_OF_DIVISION:
-        return `(mod_float ${compile(Arguments[0], Drill)} ${compile(
-          Arguments[1],
-          Drill
-        )})`
-      case KEYWORDS.BIT_TYPE:
-        return `(${compile(Arguments[0], Drill)}>>>0).toString(2)`
-      case KEYWORDS.BITWISE_NOT:
-        return `~(${compile(Arguments[0], Drill)})`
-      case KEYWORDS.NOT:
-        return `(if ${compile(Arguments[0], Drill)} == 0.0 then 1.0 else 0.0)`
-      case KEYWORDS.IF: {
-        return `(if ${compile(Arguments[0], Drill)} != 0.0 then ${compile(
-          Arguments[1],
-          Drill
-        )} else ${Arguments.length === 3 ? compile(Arguments[2], Drill) : 0})`
-      }
-      case KEYWORDS.CONDITION: {
-        let out = ''
-        for (let i = 0; i < Arguments.length; i += 2)
-          out += `(if ${compile(Arguments[i], Drill)} != 0.0 then ${compile(
-            Arguments[i + 1],
-            Drill
-          )} else `
-        out += '0.0)'
-        return out
-      }
-      // 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, Drill)
-      // }
-      case KEYWORDS.IMMUTABLE_FUNCTION: {
-        const [first, ...rest] = Arguments
-        return compile([leaf(APPLY, first[VALUE]), ...rest], Drill)
-      }
-      case KEYWORDS.NOT_COMPILED_BLOCK:
-      case KEYWORDS.TEST_CASE:
-      case KEYWORDS.TEST_BED:
-      case KEYWORDS.DOC:
-        return ''
-      default: {
-        const camelCased = lispToJavaScriptVariableName(token)
-        if (camelCased in Helpers) Drill.Helpers.add(camelCased)
-        return `${camelCased}(${parseArgs(Arguments, Drill)})`
-      }
-    }
-  } else if (first[TYPE] === ATOM)
-    return Number.isInteger(first[TYPE])
-      ? `${first[VALUE]}.0`
-      : first[VALUE].toString()
-  else if (first[TYPE] === WORD) {
-    const camelCased = lispToJavaScriptVariableName(token)
-    if (camelCased in Helpers) Drill.Helpers.add(camelCased)
-    return camelCased
-  }
-}
-const HelpersEntries = new Map(Object.entries(Helpers))
-export const comp = (ast) => {
-  const Drill = { Variables: new Set(), Helpers: new Set() }
-  const raw = ast
-    .map((tree) => compile(tree, Drill))
-    .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 help = Drill.Helpers.size
-    ? `${[...Drill.Helpers.keys()]
-        .map((x) => `let ${HelpersEntries.get(x)};;`)
-        .join('\n')}\n`
-    : ''
-
-  const top = `${help}`
-  return { top, program }
-}