fez-lisp 1.3.0 → 1.3.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "fez-lisp",
   "description": "Lisp interpreted & compiled to JavaScript",
   "author": "AT290690",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "type": "module",
   "main": "index.js",
   "keywords": [
@@ -29,6 +29,5 @@
   "license": "MIT",
   "devDependencies": {
     "mocha": "^10.2.0"
-  },
-  "dependencies": {}
+  }
 }

package/src/compiler.js

@@ -5,9 +5,9 @@ import {
   KEYWORDS,
   TYPE,
   VALUE,
-  WORD,
-  SUGGAR
+  WORD
 } from './keywords.js'
+import { SUGGAR } from './macros.js'
 import { leaf, isLeaf, AST } from './parser.js'
 const deepRename = (name, newName, tree) => {
   if (!isLeaf(tree))
@@ -58,6 +58,20 @@ const keywordToHelper = (name) => {
       return '__lt'
     case KEYWORDS.LESS_THAN_OR_EQUAL:
       return '__lteq'
+    case KEYWORDS.BITWISE_AND:
+      return '__bit_and'
+    case KEYWORDS.BITWISE_OR:
+      return '__bit_or'
+    case KEYWORDS.BITWISE_XOR:
+      return '__bit_xor'
+    case KEYWORDS.BITWISE_NOT:
+      return '__bit_not'
+    case KEYWORDS.BITWISE_LEFT_SHIFT:
+      return '__bit_lshift'
+    case KEYWORDS.BITWISE_RIGHT_SHIFT:
+      return '__bit_rshift'
+    case KEYWORDS.BITWISE_UNSIGNED_RIGHT_SHIFT:
+      return '__bit_urshift'
     default:
       return name
   }
@@ -78,32 +92,23 @@ const Helpers = {
   __add: `__add=(a,b)=>{return a+b}`,
   __sub: `__sub=function(a,b){return arguments.length===1?-a:a-b}`,
   __mult: `__mult=(a,b)=>{return a*b}`,
-  __div: `__div=function(a,b){return arguments.length===1?1/a:a/b}`,
+  __div: `__div=(a,b)=>{return a/b}`,
   __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)',
+  __bit_and: '__bit_and=(a,b)=>a&b',
+  __bit_or: '__bit_or=(a,b)=>a|b',
+  __bit_xor: '__bit_xor=(a,b)=>a^b',
+  __bit_not: '__bit_not=(a)=>~a',
+  __bit_lshift: '__bit_lshift=(a,b)=>a<<b',
+  __bit_rshift: '__bit_rshift=(a,b)=>a>>b',
+  __bit_urshift: '__bit_urshift=(a,b)=>a>>>b',
   array: 'array=(...args)=>args',
   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 0
-    }
-    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 1
-      else continue
-    }
-    return args.at(-1) ? 1 : 0
-  }`,
+  and: `and=(a, b)=>+(a&&b)`,
+  or: `or=(a, b)=>+(a||b)`,
   log_effect: `log_effect=(msg)=>{console.log(msg);return msg}`,
   log_char_effect: `log_char_effect=(msg)=>{console.log(String.fromCharCode(msg));return msg}`,
   log_string_effect: `log_string_effect=(msg)=>{console.log(msg.map(x=>String.fromCharCode(x)).join(''));return msg}`,
@@ -278,9 +283,7 @@ const compile = (tree, Drill) => {
       case KEYWORDS.MULTIPLICATION:
         return `(${parseArgs(Arguments, Drill, token)});`
       case KEYWORDS.DIVISION:
-        return Arguments.length === 1
-          ? `(1/${compile(Arguments[0], Drill)});`
-          : `(${parseArgs(Arguments, Drill, token)});`
+        return `(${parseArgs(Arguments, Drill, token)});`
       case KEYWORDS.ADDITION:
         return `(${parseArgs(Arguments, Drill, token)});`
       case KEYWORDS.BITWISE_AND:

package/src/interpreter.js

@@ -3,11 +3,11 @@ import { evaluate } from './evaluator.js'
 import { isForbiddenVariableName, stringifyArgs } from './utils.js'
 export const keywords = {
   [KEYWORDS.REMAINDER_OF_DIVISION]: (args, env) => {
-    if (args.length < 2)
+    if (args.length !== 2)
       throw new RangeError(
         `Invalid number of arguments for (${
           KEYWORDS.REMAINDER_OF_DIVISION
-        }), expected > 1 but got ${args.length}. (${
+        }), expected (= 2) but got ${args.length}. (${
           KEYWORDS.REMAINDER_OF_DIVISION
         } ${stringifyArgs(args)})`
       )
@@ -37,24 +37,10 @@ export const keywords = {
     return a % b
   },
   [KEYWORDS.DIVISION]: (args, env) => {
-    if (args.length === 1) {
-      const number = evaluate(args[0], env)
-      if (typeof number !== 'number')
-        throw new TypeError(
-          `Arguments of (${KEYWORDS.DIVISION}) is not a (${
-            KEYWORDS.NUMBER_TYPE
-          }) (${KEYWORDS.DIVISION} ${stringifyArgs(args)})`
-        )
-      if (number === 0)
-        throw new TypeError(
-          `Argument of (${
-            KEYWORDS.DIVISION
-          }) can't be a (0) (division by 0 is not allowed) (${
-            KEYWORDS.DIVISION
-          } ${stringifyArgs(args)})`
-        )
-      return 1 / number
-    }
+    if (args.length !== 2)
+      throw new RangeError(
+        `Invalid number of arguments for (${KEYWORDS.DIVISION}), expected (= 2) but got ${args.length}.`
+      )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
       throw new TypeError(
@@ -139,9 +125,9 @@ export const keywords = {
     return a + b
   },
   [KEYWORDS.MULTIPLICATION]: (args, env) => {
-    if (args.length !== 0 && args.length !== 2)
+    if (args.length !== 2)
       throw new RangeError(
-        `Invalid number of arguments for (${KEYWORDS.MULTIPLICATION}), expected (or (= 2) (= 0)) but got ${args.length}.`
+        `Invalid number of arguments for (${KEYWORDS.MULTIPLICATION}), expected (= 2) but got ${args.length}.`
       )
     const a = evaluate(args[0], env)
     if (typeof a !== 'number')
@@ -432,28 +418,22 @@ export const keywords = {
           KEYWORDS.AND
         } ${stringifyArgs(args)})`
       )
-    let circuit
-    for (let i = 0; i < args.length - 1; ++i) {
-      circuit = evaluate(args[i], env)
-      if (circuit !== FALSE && circuit !== TRUE)
-        throw new TypeError(
-          `Condition of (${
-            KEYWORDS.AND
-          }) must be ${TRUE} or ${FALSE} but got (${
-            KEYWORDS.AND
-          } ${stringifyArgs(args)})`
-        )
-      if (circuit) continue
-      else return 0
-    }
-    const end = evaluate(args.at(-1), env)
-    if (end !== FALSE && end !== TRUE)
+    const a = evaluate(args[0], env)
+    if (a !== FALSE && a !== TRUE)
       throw new TypeError(
-        `Condition of (${KEYWORDS.AND}) must be ${TRUE} or ${FALSE} but got (${
-          KEYWORDS.AND
+        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.OR
+        } ${stringifyArgs(args)})`
+      )
+    if (!a) return 0
+    const b = evaluate(args[1], env)
+    if (b !== FALSE && b !== TRUE)
+      throw new TypeError(
+        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.OR
         } ${stringifyArgs(args)})`
       )
-    return end
+    return b
   },
   [KEYWORDS.OR]: (args, env) => {
     if (args.length !== 2)
@@ -462,26 +442,22 @@ export const keywords = {
           KEYWORDS.OR
         } ${stringifyArgs(args)})`
       )
-    let circuit
-    for (let i = 0; i < args.length - 1; ++i) {
-      circuit = evaluate(args[i], env)
-      if (circuit !== FALSE && circuit !== TRUE)
-        throw new TypeError(
-          `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
-            KEYWORDS.OR
-          } ${stringifyArgs(args)})`
-        )
-      if (circuit) return 1
-      else continue
-    }
-    const end = evaluate(args.at(-1), env)
-    if (end !== FALSE && end !== TRUE)
+    const a = evaluate(args[0], env)
+    if (a !== FALSE && a !== TRUE)
+      throw new TypeError(
+        `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
+          KEYWORDS.OR
+        } ${stringifyArgs(args)})`
+      )
+    if (a) return 1
+    const b = evaluate(args[1], env)
+    if (b !== FALSE && b !== TRUE)
       throw new TypeError(
         `Condition of (${KEYWORDS.OR}) must be ${TRUE} or ${FALSE} but got (${
           KEYWORDS.OR
         } ${stringifyArgs(args)})`
       )
-    return end
+    return b
   },
   [KEYWORDS.CALL_FUNCTION]: (args, env) => {
     if (!args.length)

package/src/keywords.js

@@ -6,19 +6,6 @@ export const ATOM = 2
 export const TRUE = 1
 export const FALSE = 0
 export const PLACEHOLDER = '.'
-export const SUGGAR = {
-  // Syntactic suggars
-  PIPE: '|>',
-  NOT_EQUAL_1: '!=',
-  NOT_EQUAL_2: '<>',
-  UNLESS: 'unless',
-  LIST_TYPE: 'list',
-  POWER: '**',
-  INTEGER_DEVISION: '//',
-  CONDITION: 'cond',
-  RECURSION: 'recursive',
-  CACHE: 'memoized'
-}
 export const KEYWORDS = {
   NUMBER_TYPE: 'number',
   ARRAY_TYPE: 'array',

package/src/macros.js

@@ -0,0 +1,408 @@
+import { isLeaf } from './parser.js'
+import {
+  EXPONENTIATION,
+  INTEGER_DIVISION,
+  NOT_EQUAL
+} from '../lib/baked/macros.js'
+import {
+  APPLY,
+  ATOM,
+  FALSE,
+  KEYWORDS,
+  TRUE,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
+import { stringifyArgs } from './utils.js'
+export const SUGGAR = {
+  // Syntactic suggars
+  PIPE: '|>',
+  NOT_EQUAL_1: '!=',
+  NOT_EQUAL_2: '<>',
+  REMAINDER_OF_DIVISION_1: '%',
+  UNLESS: 'unless',
+  LIST_TYPE: 'list',
+  POWER: '**',
+  INTEGER_DEVISION: '//',
+  CONDITION: 'cond',
+  RECURSION: 'recursive',
+  CACHE: 'memoized'
+}
+export const deSuggarAst = (ast) => {
+  if (ast.length === 0) throw new SyntaxError(`No expressions to evaluate`)
+  // 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) {
+      switch (first[TYPE]) {
+        case WORD:
+          {
+            switch (first[VALUE]) {
+              case SUGGAR.REMAINDER_OF_DIVISION_1:
+                exp[VALUE] = KEYWORDS.REMAINDER_OF_DIVISION
+                break
+              case SUGGAR.NOT_EQUAL_1:
+              case SUGGAR.NOT_EQUAL_2:
+                exp.length = 0
+                exp.push(...NOT_EQUAL)
+                break
+              case SUGGAR.POWER:
+                exp.length = 0
+                exp.push(...EXPONENTIATION)
+                break
+              case SUGGAR.INTEGER_DEVISION:
+                exp.length = 0
+                exp.push(...INTEGER_DIVISION)
+                break
+            }
+          }
+          break
+        case ATOM:
+          break
+        case APPLY:
+          {
+            switch (first[VALUE]) {
+              case KEYWORDS.BLOCK:
+                {
+                  if (
+                    prev == undefined ||
+                    (prev &&
+                      prev[TYPE] === APPLY &&
+                      prev[VALUE] !== KEYWORDS.ANONYMOUS_FUNCTION)
+                  ) {
+                    exp[0][VALUE] = KEYWORDS.CALL_FUNCTION
+                    exp[0][TYPE] = APPLY
+                    exp.length = 1
+                    exp[1] = [
+                      [APPLY, KEYWORDS.ANONYMOUS_FUNCTION],
+                      [[APPLY, KEYWORDS.BLOCK], ...rest]
+                    ]
+                    deSuggarAst(exp)
+                  }
+                }
+                break
+              case SUGGAR.PIPE:
+                {
+                  if (rest.length < 1)
+                    throw new RangeError(
+                      `Invalid number of arguments to (${
+                        SUGGAR.PIPE
+                      }) (>= 1 required). (${SUGGAR.PIPE} ${stringifyArgs(
+                        rest
+                      )})`
+                    )
+                  let inp = rest[0]
+                  exp.length = 0
+                  for (let i = 1; i < rest.length; ++i) {
+                    if (!rest[i].length || rest[i][0][TYPE] !== APPLY)
+                      throw new TypeError(
+                        `Argument at position (${i}) of (${
+                          SUGGAR.PIPE
+                        }) is not an invoked (${
+                          KEYWORDS.ANONYMOUS_FUNCTION
+                        }). (${SUGGAR.PIPE} ${stringifyArgs(rest)})`
+                      )
+                    inp = [rest[i].shift(), inp, ...rest[i]]
+                  }
+                  for (let i = 0; i < inp.length; ++i) exp[i] = inp[i]
+                  deSuggarAst(exp)
+                }
+                break
+              case SUGGAR.CONDITION:
+                {
+                  if (rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.CONDITION
+                      }), expected (> 2 required) but got ${rest.length} (${
+                        SUGGAR.CONDITION
+                      } ${stringifyArgs(rest)})`
+                    )
+                  if (rest.length % 2 !== 0)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.CONDITION
+                      }), expected even number of arguments but got ${
+                        rest.length
+                      } (${SUGGAR.CONDITION} ${stringifyArgs(rest)})`
+                    )
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 2) {
+                    if (i === rest.length - 2) {
+                      temp.push([APPLY, KEYWORDS.IF], rest[i], rest.at(-1))
+                    } else {
+                      temp.push([APPLY, KEYWORDS.IF], rest[i], rest[i + 1], [])
+                      temp = temp.at(-1)
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case SUGGAR.LIST_TYPE:
+                {
+                  exp.length = 0
+                  let temp = exp
+                  for (const item of rest) {
+                    temp.push([APPLY, KEYWORDS.ARRAY_TYPE], item, [])
+                    temp = temp.at(-1)
+                  }
+                  temp.push([APPLY, KEYWORDS.ARRAY_TYPE])
+                }
+                deSuggarAst(exp)
+                break
+              case SUGGAR.INTEGER_DEVISION:
+                {
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.INTEGER_DEVISION
+                      }), expected (= 2) but got ${rest.length} (${
+                        SUGGAR.INTEGER_DEVISION
+                      } ${stringifyArgs(rest)})`
+                    )
+                  else if (rest.some((x) => x[TYPE] === APPLY)) {
+                    exp.length = 0
+                    exp.push(
+                      [0, KEYWORDS.CALL_FUNCTION],
+                      INTEGER_DIVISION,
+                      ...rest
+                    )
+                  } else {
+                    exp.length = 1
+                    exp[0] = [APPLY, KEYWORDS.BITWISE_OR]
+                    exp.push([[APPLY, KEYWORDS.DIVISION], ...rest])
+                    exp.push([ATOM, 0])
+                  }
+                }
+                break
+              case SUGGAR.POWER:
+                {
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.POWER
+                      }), expected (= 2) but got ${rest.length} (${
+                        SUGGAR.POWER
+                      } ${stringifyArgs(rest)})`
+                    )
+                  const isExponentAtom = exp[1][TYPE] === ATOM
+                  const isPowerAtom = exp[2][TYPE] === ATOM
+                  const isExponentWord = exp[1][TYPE] === WORD
+                  if ((isExponentWord || isExponentAtom) && isPowerAtom) {
+                    if (isExponentAtom) {
+                      exp[0][VALUE] = KEYWORDS.MULTIPLICATION
+                      const exponent = exp[1]
+                      const power = exp[2][VALUE]
+                      exp.length = 1
+                      exp.push(exponent, [ATOM, exponent[VALUE] ** (power - 1)])
+                    } else if (isExponentWord) {
+                      const exponent = exp[1]
+                      const power = exp[2]
+                      exp.length = 0
+                      exp.push(
+                        [0, KEYWORDS.CALL_FUNCTION],
+                        EXPONENTIATION,
+                        exponent,
+                        power
+                      )
+                    }
+                  } else {
+                    const exponent = exp[1]
+                    const power = exp[2]
+                    exp.length = 0
+                    exp.push(
+                      [0, KEYWORDS.CALL_FUNCTION],
+                      EXPONENTIATION,
+                      exponent,
+                      power
+                    )
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case KEYWORDS.MULTIPLICATION:
+                if (!rest.length) {
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = TRUE
+                } else if (rest.length > 2) {
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, KEYWORDS.MULTIPLICATION], rest[i], [])
+                      temp = temp.at(-1)
+                    } else {
+                      temp.push(...rest[i])
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case KEYWORDS.ADDITION:
+                if (!rest.length) {
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = FALSE
+                } else if (rest.length > 2) {
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, KEYWORDS.ADDITION], rest[i], [])
+                      temp = temp.at(-1)
+                    } else {
+                      temp.push(...rest[i])
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case KEYWORDS.DIVISION:
+                if (!rest.length) {
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = FALSE
+                } else if (rest.length === 1) {
+                  exp.length = 1
+                  exp.push([ATOM, 1], rest[0])
+                } else if (rest.length > 2) {
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, KEYWORDS.DIVISION], rest[i], [])
+                      temp = temp.at(-1)
+                    } else {
+                      temp.push(...rest[i])
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case KEYWORDS.AND:
+                if (!rest.length) {
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = FALSE
+                } else if (rest.length > 2) {
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, KEYWORDS.AND], rest[i], [])
+                      temp = temp.at(-1)
+                    } else {
+                      temp.push(...rest[i])
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case KEYWORDS.OR:
+                if (!rest.length) {
+                  exp[0][TYPE] = ATOM
+                  exp[0][VALUE] = FALSE
+                } else if (rest.length > 2) {
+                  exp.length = 0
+                  let temp = exp
+                  for (let i = 0; i < rest.length; i += 1) {
+                    if (i < rest.length - 1) {
+                      temp.push([APPLY, KEYWORDS.OR], rest[i], [])
+                      temp = temp.at(-1)
+                    } else {
+                      temp.push(...rest[i])
+                    }
+                  }
+                  deSuggarAst(exp)
+                }
+                break
+              case SUGGAR.UNLESS:
+                {
+                  if (rest.length > 3 || rest.length < 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        SUGGAR.UNLESS
+                      }), expected (or (= 3) (= 2)) but got ${rest.length} (${
+                        SUGGAR.UNLESS
+                      } ${stringifyArgs(rest)})`
+                    )
+                  exp[0][VALUE] = KEYWORDS.IF
+                  const temp = exp[2]
+                  exp[2] = exp[3] ?? [ATOM, FALSE]
+                  exp[3] = temp
+                }
+                deSuggarAst(exp)
+                break
+              case SUGGAR.REMAINDER_OF_DIVISION_1:
+                {
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        exp[0][1]
+                      }), expected (= 2) but got ${rest.length} (${
+                        exp[0][1]
+                      } ${stringifyArgs(rest)})`
+                    )
+                  exp[0][VALUE] = KEYWORDS.REMAINDER_OF_DIVISION
+                  deSuggarAst(exp)
+                }
+                break
+              case SUGGAR.NOT_EQUAL_1:
+              case SUGGAR.NOT_EQUAL_2:
+                {
+                  if (rest.length !== 2)
+                    throw new RangeError(
+                      `Invalid number of arguments for (${
+                        exp[0][1]
+                      }), expected (= 2) but got ${rest.length} (${
+                        exp[0][1]
+                      } ${stringifyArgs(rest)})`
+                    )
+                  exp[0][VALUE] = KEYWORDS.NOT
+                  exp[1] = [[APPLY, KEYWORDS.EQUAL], exp[1], exp[2]]
+                  exp.length = 2
+                  deSuggarAst(exp)
+                }
+                break
+            }
+            prev = first
+          }
+          break
+        default:
+          for (const e of exp) evaluate(e)
+          break
+      }
+      for (const r of rest) evaluate(r)
+    }
+  }
+  evaluate(ast)
+  return ast
+}
+export const replaceStrings = (source) => {
+  // const quotes = source.match(/"(.*?)"/g)
+  const quotes = source.match(/"(?:.*?(\n|\r))*?.*?"/g)
+  // TODO handle escaping
+  if (quotes)
+    for (const q of quotes)
+      source = source.replaceAll(
+        q,
+        `(${KEYWORDS.ARRAY_TYPE} ${[...q.replaceAll('\r', '')]
+          .slice(1, -1)
+          .map((x) => x.charCodeAt(0))
+          .join(' ')})`
+      )
+  return source
+}
+export const replaceQuotes = (source) =>
+  source
+    .replaceAll(/\'\(/g, `(${KEYWORDS.ARRAY_TYPE} `)
+    .replaceAll(/\`\(/g, `(${SUGGAR.LIST_TYPE} `)
+    .replaceAll(/\(\)/g, `(${KEYWORDS.ARRAY_TYPE})`)
+export const deSuggarSource = (source) => replaceQuotes(replaceStrings(source))
+export const handleUnbalancedQuotes = (source) => {
+  const diff = (source.match(/\"/g) ?? []).length % 2
+  if (diff !== 0) throw new SyntaxError(`Quotes are unbalanced "`)
+  return source
+}