fez-lisp 1.3.1 → 1.3.3

package/src/utils.js

@@ -1,42 +1,16 @@
 import std from '../lib/baked/std.js'
-import { comp } from './compiler.js'
-import {
-  APPLY,
-  ATOM,
-  FALSE,
-  KEYWORDS,
-  SUGGAR,
-  TRUE,
-  TYPE,
-  VALUE,
-  WORD
-} from './keywords.js'
+import { comp, OPTIMIZATIONS } from './compiler.js'
+import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
 import { evaluate, run } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
-import { EXPONENTIATION, FLOOR } from '../lib/baked/macros.js'
+import {
+  deSuggarAst,
+  deSuggarSource,
+  handleUnbalancedQuotes
+} from './macros.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log(output, '\x1b[0m')
-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,
-        `(array ${[...q.replaceAll('\r', '')]
-          .slice(1, -1)
-          .map((x) => x.charCodeAt(0))
-          .join(' ')})`
-      )
-  return source
-}
-export const replaceQuotes = (source) =>
-  source
-    .replaceAll(/\'\(/g, '(array ')
-    .replaceAll(/\`\(/g, '(list ')
-    .replaceAll(/\(\)/g, '(array)')
 // export const replaceEmptyArrays = (source) =>
 //   source
 export const removeNoCode = (source) =>
@@ -113,8 +87,8 @@ export const isForbiddenVariableName = (name) => {
   switch (name) {
     case '_':
     case KEYWORDS.DEFINE_VARIABLE:
-    case SUGGAR.RECURSION:
-    case SUGGAR.CACHE:
+    case OPTIMIZATIONS.RECURSION:
+    case OPTIMIZATIONS.CACHE:
       return true
     default:
       return !isNaN(name[0])
@@ -168,11 +142,6 @@ export const handleUnbalancedParens = (source) => {
     )
   return source
 }
-export const handleUnbalancedQuotes = (source) => {
-  const diff = (source.match(/\"/g) ?? []).length % 2
-  if (diff !== 0) throw new SyntaxError(`Quotes are unbalanced "`)
-  return source
-}
 export const removeMutation = (source) => source.replace(new RegExp(/!/g), 'ǃ')
 const isDefinition = (x) =>
   x[TYPE] === APPLY && x[VALUE] === KEYWORDS.DEFINE_VARIABLE
@@ -246,13 +215,13 @@ export const fez = (source, options = {}) => {
   const env = Object.create(null)
   try {
     if (typeof source === 'string') {
-      source = replaceQuotes(replaceStrings(source))
+      source = deSuggarSource(source)
       const valid = handleUnbalancedQuotes(
         handleUnbalancedParens(removeNoCode(source))
       )
       const code = !options.mutation ? removeMutation(valid) : valid
       if (!code.length && options.throw) throw new Error('Nothing to parse!')
-      const parsed = deSuggar(LISP.parse(code))
+      const parsed = deSuggarAst(LISP.parse(code))
       const ast = [...treeShake(parsed, std), ...parsed]
       // if (options.check) typeCheck(ast)
       if (options.compile) return comp(ast)
@@ -310,17 +279,12 @@ export const decompress = (raw) => {
 export const shake = (parsed, std) => [...treeShake(parsed, std), ...parsed]
 export const tree = (source, std) =>
   std
-    ? shake(
-        LISP.parse(replaceQuotes(replaceStrings(removeNoCode(source)))),
-        std
-      )
-    : LISP.parse(replaceQuotes(replaceStrings(removeNoCode(source))))
+    ? shake(LISP.parse(deSuggarSource(removeNoCode(source))), std)
+    : LISP.parse(deSuggarSource(removeNoCode(source)))
 export const minify = (source) =>
-  LISP.source(
-    deSuggar(LISP.parse(replaceQuotes(replaceStrings(removeNoCode(source)))))
-  )
+  LISP.source(deSuggarAst(LISP.parse(deSuggarSource(removeNoCode(source)))))
 export const prep = (source) =>
-  deSuggar(LISP.parse(removeNoCode(replaceQuotes(replaceStrings(source)))))
+  deSuggarAst(LISP.parse(removeNoCode(deSuggarSource(source))))
 export const src = (source, deps) => {
   source = prep(source)
   return LISP.source([
@@ -363,326 +327,3 @@ export const js = (source, deps) => {
   ])
   return `${top}${program}`
 }
-
-export const deSuggar = (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.POWER:
-                exp.length = 0
-                exp.push(...EXPONENTIATION)
-                break
-              case SUGGAR.INTEGER_DEVISION:
-                exp.length = 0
-                exp.push(...FLOOR)
-                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]
-                    ]
-                    deSuggar(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]
-                  deSuggar(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)
-                    }
-                  }
-                  deSuggar(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])
-                }
-                deSuggar(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], FLOOR, ...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
-                    )
-                  }
-                  deSuggar(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])
-                    }
-                  }
-                  deSuggar(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])
-                    }
-                  }
-                  deSuggar(exp)
-                }
-                break
-              case KEYWORDS.DIVISION:
-                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.DIVISION], rest[i], [])
-                      temp = temp.at(-1)
-                    } else {
-                      temp.push(...rest[i])
-                    }
-                  }
-                  deSuggar(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])
-                    }
-                  }
-                  deSuggar(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])
-                    }
-                  }
-                  deSuggar(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
-                }
-                deSuggar(exp)
-                break
-              case SUGGAR.NOT_EQUAL_1:
-              case SUGGAR.NOT_EQUAL_2:
-                {
-                  if (rest.length > 3 || rest.length < 2)
-                    throw new RangeError(
-                      `Invalid number of arguments for (${
-                        exp[0][1]
-                      }), expected (or (= 3) (= 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
-                  deSuggar(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
-}