fez-lisp 1.3.28 → 1.4.1

package/src/keywords.js

@@ -39,12 +39,7 @@ export const KEYWORDS = {
   CALL_FUNCTION: 'apply',
   DEFINE_VARIABLE: 'let',
 
-  SET_ARRAY: 'set!',
-
-  LOG: 'log!',
-  LOG_STRING: 'log-string!',
-  LOG_CHAR: 'log-char!',
-  CLEAR_CONSOLE: 'clear!'
+  SET_ARRAY: 'set!'
 }
 
 export const TYPES = {
@@ -56,3 +51,10 @@ export const RUNTIME_TYPES = {
   NUMBER: 'number',
   ARRAY: 'array'
 }
+export const DEBUG = {
+  LOG: 'log',
+  ASSERT: 'assert',
+  ERROR: 'error'
+}
+
+export const SPECIAL_FORMS_SET = new Set(Object.values(KEYWORDS))

package/src/macros.js

@@ -31,7 +31,7 @@ export const SUGGAR = {
 }
 export const deSuggarAst = (ast, scope) => {
   if (scope === undefined) scope = ast
-  if (ast.length === 0) throw new SyntaxError(`No expressions to evaluate`)
+  if (ast.length === 0) throw new SyntaxError(`No expressions...`)
   // 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`)
@@ -667,11 +667,6 @@ const iron2 = (scope, exp) => {
 }
 export const replaceQuotes = (source) =>
   source
-    .replaceAll(/\'\(/g, `(${KEYWORDS.CREATE_ARRAY} `)
-    .replaceAll(/\`\(/g, `(${SUGGAR.CREATE_LIST} `)
-    .replaceAll(/\(\)/g, `(${KEYWORDS.CREATE_ARRAY})`)
-    .replaceAll(/\[\]/g, `(${KEYWORDS.CREATE_ARRAY})`)
-    .replaceAll(/\{\}/g, `(${SUGGAR.CREATE_LIST})`)
     .replaceAll(/\[/g, `(${KEYWORDS.CREATE_ARRAY} `)
     .replaceAll(/\]/g, ')')
     .replaceAll(/\{/g, `(${SUGGAR.CREATE_LIST} `)

package/src/parser.js

@@ -30,6 +30,8 @@ export const LISP = {
   },
   stringify: (array) => {
     if (array == undefined) return '()'
+    else if (typeof array === 'function') return '(lambda)'
+    else if (typeof array === 'boolean') return +array
     else if (typeof array === 'object')
       if (Array.isArray(array))
         return array.length
@@ -39,8 +41,6 @@ export const LISP = {
         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) => {
@@ -61,7 +61,7 @@ export const LISP = {
       }
       return out
     }
-    return ast.map(dfs).join(' ')
+    return dfs(ast)
   }
 }
 export const AST = {

package/src/utils.js

@@ -1,6 +1,17 @@
 import std from '../lib/baked/std.js'
-import { comp, OPTIMIZATIONS } from './compiler.js'
-import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './keywords.js'
+import { compile, OPTIMIZATIONS } from './compiler.js'
+import {
+  APPLY,
+  ATOM,
+  DEBUG,
+  FALSE,
+  KEYWORDS,
+  RUNTIME_TYPES,
+  TRUE,
+  TYPE,
+  VALUE,
+  WORD
+} from './keywords.js'
 import { evaluate } from './evaluator.js'
 import { AST, isLeaf, LISP } from './parser.js'
 import {
@@ -12,8 +23,6 @@ import { keywords } from './interpreter.js'
 export const logError = (error) =>
   console.log('\x1b[31m', `\n${error}\n`, '\x1b[0m')
 export const logSuccess = (output) => console.log('\x1b[32m', output, '\x1b[0m')
-// export const replaceEmptyArrays = (source) =>
-//   source
 export const removeNoCode = (source) =>
   source
     .replace(/;.+/g, '')
@@ -149,6 +158,7 @@ export const handleUnbalancedParens = (source) => {
 export const removeMutation = (source) => source.replace(new RegExp(/!/g), 'ǃ')
 const isDefinition = (x) =>
   x[TYPE] === APPLY && x[VALUE] === KEYWORDS.DEFINE_VARIABLE
+// [[, [, libs]]] is because std is wrapped in (apply (lambda (do ...)))
 const toDeps = ([[, [, libs]]]) =>
   libs.reduce(
     (a, x, i) => a.set(x.at(1)[VALUE], { value: x, index: i }),
@@ -236,19 +246,18 @@ export const fez = (source, options = {}) => {
       const scope = deSuggarAst(parsed)
       const ast = wrapInBlock(shake(scope, std))
       // if (options.check) typeCheck(ast)
-      if (options.compile) return comp(ast)
+      if (options.compile) return compile(ast)
       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)
+      if (options.compile) return compile(ast)
       return evaluate(ast, env)
     } else {
       throw new Error('Source has to be either a lisp source code or an AST')
     }
   } catch (error) {
-    // console.log(error)
     const err = error.message.replace("'[object Array]'", '(array)')
     // .replace('object', '(array)')
     logError(err)
@@ -256,38 +265,6 @@ export const fez = (source, options = {}) => {
     return err
   }
 }
-export const compress = (source) => {
-  let { result, occurance } = source.split('').reduce(
-    (acc, item) => {
-      if (item === ')') acc.occurance++
-      else {
-        if (acc.occurance < 3) {
-          acc.result += ')'.repeat(acc.occurance)
-          acc.occurance = 0
-        } else {
-          acc.result += '·' + acc.occurance
-          acc.occurance = 0
-        }
-        acc.result += item
-      }
-      return acc
-    },
-    { result: '', occurance: 0 }
-  )
-  if (occurance > 0) result += '·' + occurance
-  return result
-}
-export const decompress = (raw) => {
-  const suffix = [...new Set(raw.match(/·+?\d+/g))]
-  const runes = suffix.reduce(
-    (acc, m) => acc.split(m).join(')'.repeat(parseInt(m.substring(1)))),
-    raw
-  )
-  let result = ''
-  for (const tok of runes) result += tok
-  return result
-}
-// shake(LISP.parse(removeNoCode(source)), std)
 export const shake = (parsed, std) => treeShake(parsed, std).concat(parsed)
 export const tree = (source, std) =>
   std
@@ -313,4 +290,178 @@ export const ast = (source, deps) =>
       deps.reduce((a, b) => a.concat(b), [])
     )
   )
+
 export const astWithStd = (source) => wrapInBlock(shake(prep(source), std))
+export const parse = (source) =>
+  wrapInBlock(
+    shake(
+      deSuggarAst(
+        LISP.parse(
+          removeNoCode(
+            handleUnbalancedQuotes(
+              handleUnbalancedParens(deSuggarSource(source))
+            )
+          )
+        )
+      ),
+      std
+    )
+  )
+
+const identity = (name) => [
+  [0, 'let'],
+  [1, name],
+  [
+    [0, 'lambda'],
+    [1, 'x'],
+    [1, 'x']
+  ]
+]
+export const callStack = [KEYWORDS.CALL_FUNCTION]
+export const debug = (ast) => {
+  callStack.length = 0
+  callStack.push(KEYWORDS.CALL_FUNCTION)
+  try {
+    const debugEnv = {
+      ...keywords,
+      [DEBUG.LOG]: (args, env) => {
+        if (args.length !== 1 && args.length !== 2)
+          throw new RangeError(
+            `Invalid number of arguments to (${DEBUG.LOG}) (or (= 1) (= 2)) (${
+              DEBUG.LOG
+            } ${stringifyArgs(args)})`
+          )
+        const expression = evaluate(args[0], env)
+        if (args.length === 2) {
+          const option = evaluate(args[1], env)
+          if (!Array.isArray(option)) {
+            throw new TypeError(
+              `Second argument of (${DEBUG.LOG}) must be an (${
+                RUNTIME_TYPES.ARRAY
+              }) but got (${expression}) (${DEBUG.LOG} ${stringifyArgs(args)})`
+            )
+          }
+          const type = option.map((x) => String.fromCharCode(x)).join('')
+          switch (type) {
+            case 'string':
+            case 'str':
+              {
+                if (!Array.isArray(expression))
+                  throw new TypeError(
+                    `Argument of (${DEBUG.LOG}) must be an (${
+                      RUNTIME_TYPES.ARRAY
+                    }) in the case ${type} but got (${expression}) (${
+                      DEBUG.LOG
+                    } ${stringifyArgs(args)})`
+                  )
+                console.log(
+                  expression.map((x) => String.fromCharCode(x)).join('')
+                )
+              }
+              break
+            case 'char':
+            case 'ch':
+              {
+                if (typeof expression !== 'number')
+                  throw new TypeError(
+                    `Argument argument of (${DEBUG.LOG}) must be a (${
+                      RUNTIME_TYPES.NUMBER
+                    }) in the case ${type} but got (${expression}) (${
+                      DEBUG.LOG
+                    } ${stringifyArgs(args)})`
+                  )
+                console.log(String.fromCharCode(expression))
+              }
+
+              break
+            case '*':
+              console.log(expression)
+              break
+            default:
+              throw new TypeError(
+                `Invalid number of option to (${
+                  DEBUG.LOG
+                }) got ${option} ${stringifyArgs(args)})`
+              )
+          }
+        } else console.log(expression)
+        return expression
+      },
+      [DEBUG.ERROR]: (args, env) => {
+        if (args.length !== 1)
+          throw new RangeError(
+            `Invalid number of arguments to (${DEBUG.ERROR}) (= 1 required) (${
+              DEBUG.ERROR
+            } ${stringifyArgs(args)})`
+          )
+        const expression = evaluate(args[0], env)
+        if (!Array.isArray(expression))
+          throw new TypeError(
+            `Argument of (${DEBUG.ERROR}) must be an (${
+              DEBUG.ARRAY_TYPE
+            }) but got (${expression}) (${DEBUG.ERROR} ${stringifyArgs(args)})`
+          )
+        throw new Error(expression.map((x) => String.fromCharCode(x)).join(''))
+      },
+      [DEBUG.ASSERT]: (args, env) => {
+        if (args.length < 2)
+          throw new RangeError(
+            `Invalid number of arguments for (${
+              DEBUG.ASSERT
+            }), expected (> 2 required) but got ${args.length} (${
+              DEBUG.ASSERT
+            } ${stringifyArgs(args)})`
+          )
+        if (args.length % 2 !== 0)
+          throw new RangeError(
+            `Invalid number of arguments for (${
+              DEBUG.ASSERT
+            }), expected even number of arguments but got ${args.length} (${
+              DEBUG.ASSERT
+            } ${stringifyArgs(args)})`
+          )
+        for (let i = 0; i < args.length; i += 2) {
+          const condition = evaluate(args[i], env)
+          if (condition !== FALSE && condition !== TRUE)
+            throw new TypeError(
+              `Condition of (${
+                DEBUG.ASSERT
+              }) must be ${TRUE} or ${FALSE} but got (${
+                DEBUG.ASSERT
+              } ${stringifyArgs(args)})`
+            )
+          if (condition) {
+            const error = args[i + 1]
+            if (error[0][TYPE] === APPLY && error[0][VALUE] === DEBUG.ERROR)
+              return evaluate(error, env)
+            else
+              throw new TypeError(
+                `Concequence of (${DEBUG.ASSERT}) must be (${
+                  DEBUG.ERROR
+                }) but got (${DEBUG.ASSERT} ${stringifyArgs(args)})`
+              )
+          }
+        }
+        return 0
+      }
+    }
+    evaluate(ast, debugEnv)
+  } catch (error) {
+    const isMaxCallStack =
+      error.message.includes('Maximum call stack size exceeded') ||
+      error.message.includes('too much recursion')
+    if (!isMaxCallStack) {
+      error.message += `\n\nscope:\n(${callStack.at(-1)})`
+      throw error
+    } else logError(error.message)
+  }
+  const block = ast[1][1]
+  const temp = block.shift()
+  block.unshift(
+    temp,
+    identity(DEBUG.LOG),
+    identity(DEBUG.ERROR),
+    identity(DEBUG.ASSERT)
+  )
+  return compile(ast)
+}