fez-lisp 1.0.0

package/src/enums.js

@@ -0,0 +1,79 @@
+// AST enums
+export const WORD = 'w'
+export const APPLY = 'f'
+export const VALUE = 'v'
+export const TYPE = 't'
+export const ATOM = 'a'
+// tokeniser enums
+export const PLACEHOLDER = '.'
+// keywords aliases
+export const KEYWORDS = {
+  BIT_TYPE: 'Bit',
+  STRING_TYPE: 'String',
+  NUMBER_TYPE: 'Number',
+  BOOLEAN_TYPE: 'Boolean',
+  FUNCTION_TYPE: 'Function',
+  ARRAY_TYPE: 'Array',
+  CHAR_CODE_TYPE: 'Char-Code',
+  CHAR_TYPE: 'Char',
+
+  CAST_TYPE: 'type',
+  CONCATENATION: 'concatenate',
+  ARRAY_OR_STRING_LENGTH: 'length',
+  IS_ARRAY: 'Array?',
+  IS_NUMBER: 'Number?',
+  IS_STRING: 'String?',
+  IS_FUNCTION: 'Function?',
+
+  ADDITION: '+',
+  SUBTRACTION: '-',
+  MULTIPLICATION: '*',
+  DIVISION: '/',
+  REMAINDER_OF_DIVISION: 'mod',
+
+  BITWISE_AND: '&',
+  BITWISE_OR: '|',
+  BITWISE_NOT: '~',
+  BITWISE_XOR: '^',
+  BITWISE_LEFT_SHIFT: '<<',
+  BITWISE_RIGHT_SHIFT: '>>',
+  BITWISE_UNSIGNED_RIGHT_SHIFT: '>>>',
+  ATOM: 'Atom',
+  IS_ATOM: 'Atom?',
+  FIRST_ARRAY: 'car',
+  REST_ARRAY: 'cdr',
+  GET_ARRAY: 'get',
+
+  BLOCK: 'do',
+
+  MERGE: 'merge',
+  ANONYMOUS_FUNCTION: 'lambda',
+
+  IF: 'if',
+  UNLESS: 'unless',
+  WHEN: 'when',
+  OTHERWISE: 'otherwise',
+  CONDITION: 'cond',
+
+  NOT: 'not',
+  EQUAL: '=',
+  LESS_THAN: '<',
+  GREATHER_THAN: '>',
+  GREATHER_THAN_OR_EQUAL: '>=',
+  LESS_THAN_OR_EQUAL: '<=',
+  AND: 'and',
+  OR: 'or',
+  CALL_FUNCTION: 'apply',
+  DEFINE_VARIABLE: 'let',
+
+  PIPE: 'go',
+  THROW_ERROR: 'throw',
+  TAIL_CALLS_OPTIMISED_RECURSIVE_FUNCTION: 'let*',
+  IMMUTABLE_FUNCTION: 'safety',
+  NOT_COMPILED_BLOCK: 'void',
+  LOG: 'log!',
+
+  TEST_CASE: 'case',
+  TEST_BED: 'assert',
+  SERIALISE: 'serialise',
+}

package/src/interpreter.js

@@ -0,0 +1,29 @@
+import { APPLY, ATOM, KEYWORDS, TYPE, VALUE, WORD } from './enums.js'
+import { keywords } from './tokeniser.js'
+import { stringifyArgs } from './utils.js'
+
+export const evaluate = (expression, env) => {
+  const [first, ...rest] = Array.isArray(expression) ? expression : [expression]
+  if (first == undefined) return []
+  switch (first[TYPE]) {
+    case WORD: {
+      const word = env[first[VALUE]]
+      if (word == undefined)
+        throw new ReferenceError(`Undefined variable ${first[VALUE]}.`)
+      return word
+    }
+    case APPLY:
+      const apply = env[first[VALUE]]
+      if (typeof apply !== 'function')
+        throw new TypeError(`${first[VALUE]} is not a (function).`)
+      return apply(rest, env)
+    case ATOM:
+      return first[VALUE]
+    default:
+      throw new ReferenceError(
+        `Attempting to acces Undefined near ${stringifyArgs(expression)}`
+      )
+  }
+}
+export const run = (tree, env = {}) =>
+  keywords[KEYWORDS.BLOCK](tree, { ...keywords, ...env })

package/src/parser.js

@@ -0,0 +1,45 @@
+import { APPLY, ATOM, TYPE, VALUE, WORD } from './enums.js'
+import { escape } from './utils.js'
+
+export const parse = (source) => {
+  const tree = []
+  let head = tree,
+    stack = [tree],
+    acc = ''
+  for (let i = 0; i < source.length; ++i) {
+    const cursor = source[i]
+    if (cursor === '"') {
+      acc += '"'
+      ++i
+      while (source[i] !== '"') {
+        if (source[i] === '\\') acc += escape(source[++i])
+        else acc += source[i]
+        ++i
+      }
+    }
+    if (cursor === '(') {
+      head.push([])
+      stack.push(head)
+      head = head.at(-1)
+    } else if (cursor === ')' || cursor === ' ') {
+      let token = acc
+      acc = ''
+      if (token) {
+        if (!head.length) head.push({ [TYPE]: APPLY, [VALUE]: token })
+        else if (token.match(/^"([^"]*)"/))
+          head.push({
+            [TYPE]: ATOM,
+            [VALUE]: token.substring(1, token.length - 1),
+          })
+        else if (token.match(/^-?[0-9]\d*(\.\d+)?$/))
+          head.push({
+            [TYPE]: ATOM,
+            [VALUE]: Number(token),
+          })
+        else head.push({ [TYPE]: WORD, [VALUE]: token })
+      }
+      if (cursor === ')') head = stack.pop()
+    } else acc += cursor
+  }
+  return tree
+}