conjure-js 0.0.13 → 0.0.14

package/src/core/evaluator/dispatch.ts

@@ -1,7 +1,7 @@
 import { is } from '../assertions'
 import { EvaluationError } from '../errors'
 import { printString } from '../printer'
-import { getPos } from '../positions'
+import { maybeHydrateErrorPos } from '../positions'
 import type {
   CljList,
   CljValue,
@@ -12,7 +12,10 @@ import type {
 
 import { evaluateSpecialForm } from './special-forms'
 
-function dispatchMultiMethod(
+const LIST_HEAD_POS = 0
+const LIST_BODY_POS = 1
+
+export function dispatchMultiMethod(
   mm: CljMultiMethod,
   args: CljValue[],
   ctx: EvaluationContext,
@@ -45,39 +48,33 @@ export function evaluateList(
   if (list.value.length === 0) {
     return list
   }
-  const first = list.value[0]
+  const head = list.value[LIST_HEAD_POS]
 
-  if (is.specialForm(first)) {
-    return evaluateSpecialForm(first.name, list, env, ctx)
+  if (is.specialForm(head)) {
+    return evaluateSpecialForm(head.name, list, env, ctx)
   }
 
-  const evaledFirst = ctx.evaluate(first, env)
+  const evaledHead = ctx.evaluate(head, env)
 
-  if (is.multiMethod(evaledFirst)) {
-    const args = list.value.slice(1).map((v) => ctx.evaluate(v, env))
-    return dispatchMultiMethod(evaledFirst, args, ctx, env)
+  if (is.multiMethod(evaledHead)) {
+    const args = list.value
+      .slice(LIST_BODY_POS)
+      .map((arg) => ctx.evaluate(arg, env))
+    return dispatchMultiMethod(evaledHead, args, ctx, env)
   }
 
-  if (!is.callable(evaledFirst)) {
-    const name = is.symbol(first) ? first.name : printString(first)
+  if (!is.callable(evaledHead)) {
+    const name = is.symbol(head) ? head.name : printString(head)
     throw new EvaluationError(`${name} is not callable`, { list, env })
   }
 
-  const args = list.value.slice(1).map((v) => ctx.evaluate(v, env))
+  const args = list.value
+    .slice(LIST_BODY_POS)
+    .map((arg) => ctx.evaluate(arg, env))
   try {
-    return ctx.applyCallable(evaledFirst, args, env)
+    return ctx.applyCallable(evaledHead, args, env)
   } catch (e) {
-    if (
-      e instanceof EvaluationError &&
-      e.data?.argIndex !== undefined &&
-      !e.pos
-    ) {
-      const argForm = list.value[(e.data.argIndex as number) + 1]
-      if (argForm) {
-        const pos = getPos(argForm)
-        if (pos) e.pos = pos
-      }
-    }
+    maybeHydrateErrorPos(e, list)
     throw e
   }
 }

package/src/core/evaluator/evaluate.ts

@@ -1,9 +1,17 @@
+/**
+ * Evaluator - Core entrypoint
+ * Handles the evaluation of a single expression.
+ * Delegates most of the work to domain handlers.
+ * Uses the compiler to compile the expression to a closure when possible.
+ * The interpreter is the source of truth for the semantics of the language.
+ */
+
+import { compile } from '../compiler'
 import { derefValue, getNamespaceEnv, lookup } from '../env'
 import { EvaluationError } from '../errors'
 import { v } from '../factories'
+import { valueKeywords } from '../keywords.ts'
 import { getPos } from '../positions'
-import { valueKeywords } from '../types'
-
 import type { CljValue, Env, EvaluationContext } from '../types'
 import { evaluateMap, evaluateSet, evaluateVector } from './collections'
 import { evaluateList } from './dispatch'
@@ -24,6 +32,10 @@ export function evaluateWithContext(
   ctx: EvaluationContext
 ): CljValue {
   try {
+    const compiled = compile(expr)
+    if (compiled !== null) {
+      return compiled(env, ctx)
+    }
     switch (expr.kind) {
       // self-evaluating forms
       case valueKeywords.number:

package/src/core/evaluator/expand.ts

@@ -1,6 +1,6 @@
 import { is } from '../assertions'
 import { derefValue, getNamespaceEnv, tryLookup } from '../env'
-import { cljList, cljMap, cljVector } from '../factories'
+import { v } from '../factories'
 import type { CljValue, Env, EvaluationContext } from '../types'
 
 /**
@@ -31,7 +31,7 @@ export function macroExpandAllWithContext(
     )
     return expanded.every((e, i) => e === form.value[i])
       ? form
-      : cljVector(expanded)
+      : v.vector(expanded)
   }
 
   // Maps: expand each key and value
@@ -47,7 +47,7 @@ export function macroExpandAllWithContext(
       ([k, v], i) => k === form.entries[i][0] && v === form.entries[i][1]
     )
       ? form
-      : cljMap(expanded)
+      : v.map(expanded)
   }
 
   // Atoms (number, string, boolean, keyword, nil, symbol, regex, functions, etc.)
@@ -65,7 +65,7 @@ export function macroExpandAllWithContext(
     )
     return expanded.every((e, i) => e === form.value[i])
       ? form
-      : cljList(expanded)
+      : v.list(expanded)
   }
 
   const name = first.name
@@ -103,7 +103,5 @@ export function macroExpandAllWithContext(
   const expanded = form.value.map((sub) =>
     macroExpandAllWithContext(sub, env, ctx)
   )
-  return expanded.every((e, i) => e === form.value[i])
-    ? form
-    : cljList(expanded)
+  return expanded.every((e, i) => e === form.value[i]) ? form : v.list(expanded)
 }

package/src/core/evaluator/js-interop.ts

@@ -1,6 +1,6 @@
 import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import { cljBoolean, cljJsValue, cljNil, cljNumber, cljString } from '../factories'
+import { v } from '../factories'
 import type { CljList, CljValue, Env, EvaluationContext } from '../types'
 
 // ---------------------------------------------------------------------------
@@ -14,12 +14,12 @@ import type { CljList, CljValue, Env, EvaluationContext } from '../types'
  * - primitives convert; everything else boxes.
  */
 export function jsToClj(raw: unknown): CljValue {
-  if (raw === null) return cljNil()
-  if (raw === undefined) return cljJsValue(undefined)
-  if (typeof raw === 'number') return cljNumber(raw)
-  if (typeof raw === 'string') return cljString(raw)
-  if (typeof raw === 'boolean') return cljBoolean(raw)
-  return cljJsValue(raw)
+  if (raw === null) return v.nil()
+  if (raw === undefined) return v.jsValue(undefined)
+  if (typeof raw === 'number') return v.number(raw)
+  if (typeof raw === 'string') return v.string(raw)
+  if (typeof raw === 'boolean') return v.boolean(raw)
+  return v.jsValue(raw)
 }
 
 /**
@@ -28,13 +28,13 @@ export function jsToClj(raw: unknown): CljValue {
  * have no meaningful JS representation and must be reduced to a primitive first.
  */
 function mapKeyToString(key: CljValue): string {
-  if (key.kind === 'string') return key.value
-  if (key.kind === 'keyword') return key.name.slice(1) // strip leading ':'
-  if (key.kind === 'number') return String(key.value)
-  if (key.kind === 'boolean') return String(key.value)
+  if (is.string(key)) return key.value
+  if (is.keyword(key)) return key.name.slice(1) // strip leading ':'
+  if (is.number(key)) return String(key.value)
+  if (is.boolean(key)) return String(key.value)
   throw new EvaluationError(
     `cljToJs: map key must be a string, keyword, number, or boolean — ` +
-    `got ${key.kind} (rich keys are not allowed as JS object keys; reduce to a primitive first)`,
+      `got ${key.kind} (rich keys are not allowed as JS object keys; reduce to a primitive first)`,
     { key }
   )
 }
@@ -43,14 +43,24 @@ function mapKeyToString(key: CljValue): string {
  * Convert a CljValue to a raw JS value for crossing the interop boundary.
  * Called on each argument passed to `.` and `js/new`.
  */
-export function cljToJs(val: CljValue, ctx: EvaluationContext, callEnv: Env): unknown {
+export function cljToJs(
+  val: CljValue,
+  ctx: EvaluationContext,
+  callEnv: Env
+): unknown {
   switch (val.kind) {
-    case 'js-value': return val.value
-    case 'number': return val.value
-    case 'string': return val.value
-    case 'boolean': return val.value
-    case 'nil': return null
-    case 'keyword': return val.name.slice(1) // strip leading ':'
+    case 'js-value':
+      return val.value
+    case 'number':
+      return val.value
+    case 'string':
+      return val.value
+    case 'boolean':
+      return val.value
+    case 'nil':
+      return null
+    case 'keyword':
+      return val.name.slice(1) // strip leading ':'
     case 'function':
     case 'native-function': {
       const fn = val
@@ -90,15 +100,14 @@ export function cljToJs(val: CljValue, ctx: EvaluationContext, callEnv: Env): un
  */
 function extractRawTarget(target: CljValue): unknown {
   switch (target.kind) {
-    case 'js-value': return target.value
+    case 'js-value':
+      return target.value
     case 'string':
     case 'number':
-    case 'boolean': return target.value
+    case 'boolean':
+      return target.value
     default:
-      throw new EvaluationError(
-        `cannot use . on ${target.kind}`,
-        { target }
-      )
+      throw new EvaluationError(`cannot use . on ${target.kind}`, { target })
   }
 }
 
@@ -108,10 +117,9 @@ export function evaluateDot(
   ctx: EvaluationContext
 ): CljValue {
   if (list.value.length < 3) {
-    throw new EvaluationError(
-      '. requires at least 2 arguments: (. obj prop)',
-      { list }
-    )
+    throw new EvaluationError('. requires at least 2 arguments: (. obj prop)', {
+      list,
+    })
   }
 
   const target = ctx.evaluate(list.value[1], env)
@@ -141,7 +149,7 @@ export function evaluateDot(
     // Functions are bound to their object so that ((. obj method)) works correctly.
     const rawProp = rawObj[propName]
     if (typeof rawProp === 'function') {
-      return cljJsValue((rawProp as (...a: unknown[]) => unknown).bind(rawObj))
+      return v.jsValue((rawProp as (...a: unknown[]) => unknown).bind(rawObj))
     }
     return jsToClj(rawProp)
   }
@@ -157,7 +165,10 @@ export function evaluateDot(
 
   const cljArgs = list.value.slice(3).map((a) => ctx.evaluate(a, env))
   const jsArgs = cljArgs.map((a) => cljToJs(a, ctx, env))
-  const rawResult = (method as (...args: unknown[]) => unknown).apply(rawObj, jsArgs)
+  const rawResult = (method as (...args: unknown[]) => unknown).apply(
+    rawObj,
+    jsArgs
+  )
   return jsToClj(rawResult)
 }
 
@@ -171,7 +182,9 @@ export function evaluateNew(
   ctx: EvaluationContext
 ): CljValue {
   if (list.value.length < 2) {
-    throw new EvaluationError('js/new requires a constructor argument', { list })
+    throw new EvaluationError('js/new requires a constructor argument', {
+      list,
+    })
   }
 
   const cls = ctx.evaluate(list.value[1], env)
@@ -185,5 +198,5 @@ export function evaluateNew(
   const cljArgs = list.value.slice(2).map((a) => ctx.evaluate(a, env))
   const jsArgs = cljArgs.map((a) => cljToJs(a, ctx, env))
   const ctor = cls.value as new (...args: unknown[]) => unknown
-  return cljJsValue(new ctor(...jsArgs))
+  return v.jsValue(new ctor(...jsArgs))
 }

package/src/core/evaluator/quasiquote.ts

@@ -1,14 +1,10 @@
 import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import { cljList, cljMap, cljVector } from '../factories'
-import { toSeq } from '../transformations'
+import { v } from '../factories'
 import { makeGensym } from '../gensym'
-import {
-  type CljValue,
-  type Env,
-  type EvaluationContext,
-  valueKeywords,
-} from '../types'
+import { valueKeywords } from '../keywords'
+import { toSeq } from '../transformations'
+import { type CljValue, type Env, type EvaluationContext } from '../types'
 
 export function evaluateQuasiquote(
   form: CljValue,
@@ -58,7 +54,7 @@ export function evaluateQuasiquote(
         // Otherwise, recursively evaluate the quasiquote
         elements.push(evaluateQuasiquote(elem, env, autoGensyms, ctx))
       }
-      return isAList ? cljList(elements) : cljVector(elements)
+      return isAList ? v.list(elements) : v.vector(elements)
     }
     case valueKeywords.map: {
       const entries: [CljValue, CljValue][] = []
@@ -67,7 +63,7 @@ export function evaluateQuasiquote(
         const evaluatedValue = evaluateQuasiquote(value, env, autoGensyms, ctx)
         entries.push([evaluatedKey, evaluatedValue])
       }
-      return cljMap(entries)
+      return v.map(entries)
     }
     case valueKeywords.number:
     case valueKeywords.string:
@@ -83,7 +79,7 @@ export function evaluateQuasiquote(
         if (!autoGensyms.has(form.name)) {
           autoGensyms.set(form.name, makeGensym(form.name.slice(0, -1)))
         }
-        return { kind: 'symbol', name: autoGensyms.get(form.name)! }
+        return v.symbol(autoGensyms.get(form.name)!)
       }
       return form
     }

package/src/core/evaluator/recur-check.ts

@@ -1,7 +1,7 @@
 import { is } from '../assertions'
 import { EvaluationError } from '../errors'
+import { specialFormKeywords } from '../keywords.ts'
 import type { CljValue } from '../types'
-import { specialFormKeywords } from './special-forms'
 
 /**
  * Asserts that every `recur` form in `body` appears strictly in tail position.

package/src/core/evaluator/special-forms.ts

@@ -13,6 +13,7 @@ import { v } from '../factories'
 // --- ASYNC (experimental) ---
 import { createAsyncEvalCtx } from './async-evaluator'
 // --- END ASYNC ---
+import { specialFormKeywords } from '../keywords.ts'
 import { getLineCol, getPos } from '../positions'
 import type {
   CljFunction,
@@ -27,14 +28,16 @@ import type {
 } from '../types'
 import { parseArities, RecurSignal } from './arity'
 import { destructureBindings } from './destructure'
-import { evaluateDot, evaluateNew } from './js-interop'
-import { evaluateQuasiquote } from './quasiquote'
-import { assertRecurInTailPosition } from './recur-check'
 import {
   matchesDiscriminator,
   parseTryStructure,
   validateBindingVector,
 } from './form-parsers'
+import { evaluateDot, evaluateNew } from './js-interop'
+import { evaluateQuasiquote } from './quasiquote'
+import { assertRecurInTailPosition } from './recur-check'
+
+import { compile } from '../compiler/index.ts'
 
 function hasDynamicMeta(meta: CljMap | undefined): boolean {
   if (!meta) return false
@@ -51,36 +54,6 @@ function hasDynamicMeta(meta: CljMap | undefined): boolean {
   return false
 }
 
-export const specialFormKeywords = {
-  quote: 'quote',
-  def: 'def',
-  if: 'if',
-  do: 'do',
-  let: 'let',
-  fn: 'fn',
-  defmacro: 'defmacro',
-  quasiquote: 'quasiquote',
-  ns: 'ns',
-  loop: 'loop',
-  recur: 'recur',
-  defmulti: 'defmulti',
-  defmethod: 'defmethod',
-  try: 'try',
-  var: 'var',
-  binding: 'binding',
-  'set!': 'set!',
-  letfn: 'letfn',
-  delay: 'delay',
-  'lazy-seq': 'lazy-seq',
-  // --- ASYNC (experimental) ---
-  async: 'async',
-  // --- END ASYNC ---
-  // --- JS INTEROP ---
-  '.': '.',
-  'js/new': 'js/new',
-  // --- END JS INTEROP ---
-} as const
-
 function keywordToDispatchFn(kw: CljKeyword): CljNativeFunction {
   return v.nativeFn(`kw:${kw.name}`, (...args: CljValue[]) => {
     const target = args[0]
@@ -95,10 +68,7 @@ function evaluateTry(
   env: Env,
   ctx: EvaluationContext
 ): CljValue {
-  const { bodyForms, catchClauses, finallyForms } = parseTryStructure(
-    list,
-    env
-  )
+  const { bodyForms, catchClauses, finallyForms } = parseTryStructure(list, env)
 
   let result: CljValue = v.nil()
   let pendingThrow: unknown = null
@@ -294,13 +264,23 @@ function evaluateFn(
   // (fn name [...] ...) — optional name symbol before the param vector/arities
   let fnName: string | undefined
   let arityForms = rest
-  if (rest[0]?.kind === 'symbol') {
+  if (rest[0] && is.symbol(rest[0])) {
     fnName = rest[0].name
     arityForms = rest.slice(1)
   }
   const arities = parseArities(arityForms, env)
   for (const arity of arities) {
     assertRecurInTailPosition(arity.body)
+    // Try to compile this arity
+    // store the compiled body if successful
+    // wrap the body in a do form so the compiler can handle it
+    // at the top level dispatcher
+    const compiled = compile(
+      v.list([v.symbol(specialFormKeywords.do), ...arity.body])
+    )
+    if (compiled !== null) {
+      arity.compiledBody = compiled
+    }
   }
   const fn = v.multiArityFunction(arities, env)
   if (fnName) {

package/src/core/index.ts

@@ -12,7 +12,7 @@ export type { Runtime, RuntimeSnapshot, RuntimeOptions } from './runtime'
 
 // Module system
 export { resolveModuleOrder } from './module'
-export { makeCoreModule } from './core-module'
+export { makeCoreModule } from './modules/core'
 export type {
   RuntimeModule,
   NamespaceDeclaration,

package/src/core/keywords.ts

@@ -0,0 +1,105 @@
+export const specialFormKeywords = {
+  // Core forms
+  def: 'def',
+  do: 'do',
+  fn: 'fn',
+  if: 'if',
+  let: 'let',
+  loop: 'loop',
+  recur: 'recur',
+  quote: 'quote',
+  try: 'try',
+  var: 'var',
+  // Namespace form
+  ns: 'ns',
+  // Macro forms
+  defmacro: 'defmacro',
+  quasiquote: 'quasiquote',
+  // Multi methods
+  defmulti: 'defmulti',
+  defmethod: 'defmethod',
+  // Binding forms
+  binding: 'binding',
+  'set!': 'set!',
+  letfn: 'letfn',
+  // Lazy forms
+  delay: 'delay',
+  'lazy-seq': 'lazy-seq',
+  async: 'async',
+  // JS INTEROP
+  '.': '.',
+  'js/new': 'js/new',
+} as const
+
+export const valueKeywords = {
+  // Core values
+  boolean: 'boolean',
+  function: 'function',
+  nativeFunction: 'native-function',
+  keyword: 'keyword',
+  list: 'list',
+  macro: 'macro',
+  map: 'map',
+  nil: 'nil',
+  number: 'number',
+  regex: 'regex',
+  set: 'set',
+  string: 'string',
+  symbol: 'symbol',
+  vector: 'vector',
+  // Stateful values
+  atom: 'atom',
+  delay: 'delay',
+  multiMethod: 'multi-method',
+  volatile: 'volatile',
+  var: 'var',
+  // Exotic values
+  cons: 'cons',
+  lazySeq: 'lazy-seq',
+  reduced: 'reduced',
+  // Async value
+  pending: 'pending',
+  // Namespace representation
+  namespace: 'namespace',
+  // Boxed JS values, Interop containers
+  jsValue: 'js-value',
+} as const
+/** Tokens */
+export const tokenKeywords = {
+  LParen: 'LParen',
+  RParen: 'RParen',
+  LBracket: 'LBracket',
+  RBracket: 'RBracket',
+  LBrace: 'LBrace',
+  RBrace: 'RBrace',
+  String: 'String',
+  Number: 'Number',
+  Keyword: 'Keyword',
+  Quote: 'Quote',
+  Quasiquote: 'Quasiquote',
+  Unquote: 'Unquote',
+  UnquoteSplicing: 'UnquoteSplicing',
+  Comment: 'Comment',
+  Whitespace: 'Whitespace',
+  Symbol: 'Symbol',
+  AnonFnStart: 'AnonFnStart',
+  Deref: 'Deref',
+  Regex: 'Regex',
+  VarQuote: 'VarQuote',
+  Meta: 'Meta',
+  SetStart: 'SetStart',
+} as const
+export const tokenSymbols = {
+  Quote: 'quote',
+  Quasiquote: 'quasiquote',
+  Unquote: 'unquote',
+  UnquoteSplicing: 'unquote-splicing',
+  LParen: '(',
+  RParen: ')',
+  LBracket: '[',
+  RBracket: ']',
+  LBrace: '{',
+  RBrace: '}',
+} as const
+export type TokenSymbols = (typeof tokenSymbols)[keyof typeof tokenSymbols]
+export type TokenKinds = keyof typeof tokenKeywords