conjure-js 0.0.13 → 0.0.14

package/src/core/evaluator/async-evaluator.ts

@@ -43,7 +43,8 @@
 import { is } from '../assertions'
 import { extend } from '../env'
 import { CljThrownSignal, EvaluationError } from '../errors'
-import { cljNil } from '../factories'
+import { cljNil, v } from '../factories'
+import { specialFormKeywords, valueKeywords } from '../keywords'
 import type { CljList, CljValue, Env, EvaluationContext } from '../types'
 import { bindParams, RecurSignal, resolveArity } from './arity'
 import { destructureBindings } from './destructure'
@@ -89,56 +90,56 @@ async function evaluateFormAsync(
   // Self-evaluating forms and symbols: delegate directly to sync evaluator.
   // No async needed — these don't contain sub-expressions that could be pending.
   switch (expr.kind) {
-    case 'number':
-    case 'string':
-    case 'boolean':
-    case 'keyword':
-    case 'nil':
-    case 'symbol':
-    case 'function':
-    case 'native-function':
-    case 'macro':
-    case 'multi-method':
-    case 'atom':
-    case 'reduced':
-    case 'volatile':
-    case 'regex':
-    case 'var':
-    case 'delay':
-    case 'lazy-seq':
-    case 'cons':
-    case 'namespace':
-    case 'pending':
+    case valueKeywords.number:
+    case valueKeywords.string:
+    case valueKeywords.boolean:
+    case valueKeywords.keyword:
+    case valueKeywords.nil:
+    case valueKeywords.symbol:
+    case valueKeywords.function:
+    case valueKeywords.nativeFunction:
+    case valueKeywords.macro:
+    case valueKeywords.multiMethod:
+    case valueKeywords.atom:
+    case valueKeywords.reduced:
+    case valueKeywords.volatile:
+    case valueKeywords.regex:
+    case valueKeywords.var:
+    case valueKeywords.delay:
+    case valueKeywords.lazySeq:
+    case valueKeywords.cons:
+    case valueKeywords.namespace:
+    case valueKeywords.pending:
       return asyncCtx.syncCtx.evaluate(expr, env)
   }
 
-  if (expr.kind === 'vector') {
+  if (is.vector(expr)) {
     const elements: CljValue[] = []
     for (const el of expr.value) {
       elements.push(await evaluateFormAsync(el, env, asyncCtx))
     }
-    return { kind: 'vector', value: elements }
+    return v.vector(elements)
   }
 
-  if (expr.kind === 'map') {
+  if (is.map(expr)) {
     const entries: [CljValue, CljValue][] = []
     for (const [k, v] of expr.entries) {
       const ek = await evaluateFormAsync(k, env, asyncCtx)
       const ev = await evaluateFormAsync(v, env, asyncCtx)
       entries.push([ek, ev])
     }
-    return { kind: 'map', entries }
+    return v.map(entries)
   }
 
-  if (expr.kind === 'set') {
+  if (is.set(expr)) {
     const elements: CljValue[] = []
     for (const el of expr.values) {
       elements.push(await evaluateFormAsync(el, env, asyncCtx))
     }
-    return { kind: 'set', values: elements }
+    return v.set(elements)
   }
 
-  if (expr.kind === 'list') {
+  if (is.list(expr)) {
     return evaluateListAsync(expr, env, asyncCtx)
   }
 
@@ -151,7 +152,7 @@ async function evaluateFormsAsync(
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
-  let result: CljValue = cljNil()
+  let result: CljValue = v.nil()
   for (const form of forms) {
     const expanded = asyncCtx.syncCtx.expandAll(form, env)
     result = await evaluateFormAsync(expanded, env, asyncCtx)
@@ -196,28 +197,28 @@ const ASYNC_SPECIAL_FORMS = new Set([
 ])
 
 async function evaluateListAsync(
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
   if (list.value.length === 0) return list
 
-  const first = list.value[0]
+  const head = list.value[0]
 
   // Special forms: dispatch to async-aware handlers for the ones that need it,
   // delegate to sync ctx for safe ones (quote, var, fn, ns).
-  if (first.kind === 'symbol' && ASYNC_SPECIAL_FORMS.has(first.name)) {
-    return evaluateSpecialFormAsync(first.name, list, env, asyncCtx)
+  if (is.symbol(head) && ASYNC_SPECIAL_FORMS.has(head.name)) {
+    return evaluateSpecialFormAsync(head.name, list, env, asyncCtx)
   }
 
   // Evaluate the head (function position)
-  const fn = await evaluateFormAsync(first, env, asyncCtx)
+  const fn = await evaluateFormAsync(head, env, asyncCtx)
 
   // Deref interception: @x expands to (deref x).
   // If the dereffed value is CljPending, await it here — this is the heart of async @.
   if (is.aFunction(fn) && fn.name === 'deref' && list.value.length === 2) {
     const val = await evaluateFormAsync(list.value[1], env, asyncCtx)
-    if (val.kind === 'pending') {
+    if (is.pending(val)) {
       return val.promise // await the pending value
     }
     // Not pending: normal sync deref
@@ -237,22 +238,21 @@ async function evaluateListAsync(
 
 async function evaluateSpecialFormAsync(
   name: string,
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
   switch (name) {
     // Safe to delegate to sync: no sub-evaluation of async expressions
-    case 'quote':
-    case 'var':
-    case 'ns':
+    case specialFormKeywords.quote:
+    case specialFormKeywords.var:
+    case specialFormKeywords.ns:
     // fn/fn*: function CREATION is sync — the body is evaluated async only when called
-    case 'fn':
-    case 'fn*':
+    case specialFormKeywords.fn:
       return asyncCtx.syncCtx.evaluate(list, env)
 
     // recur: evaluate args async, then throw RecurSignal
-    case 'recur': {
+    case specialFormKeywords.recur: {
       const args: CljValue[] = []
       for (const arg of list.value.slice(1)) {
         args.push(await evaluateFormAsync(arg, env, asyncCtx))
@@ -261,70 +261,58 @@ async function evaluateSpecialFormAsync(
     }
 
     // do: sequential evaluation
-    case 'do':
+    case specialFormKeywords.do:
       return evaluateFormsAsync(list.value.slice(1), env, asyncCtx)
 
     // def: V1 does not support def inside (async ...) — unusual use case
-    case 'def':
+    case specialFormKeywords.def:
       throw new EvaluationError(
         'def inside (async ...) is not supported. Define vars outside the async block.',
         { list, env }
       )
 
     // if: evaluate condition, then selected branch
-    case 'if': {
+    case specialFormKeywords.if: {
       const condition = await evaluateFormAsync(list.value[1], env, asyncCtx)
       const isTruthy =
-        condition.kind !== 'nil' &&
-        !(condition.kind === 'boolean' && !condition.value)
+        !is.nil(condition) && !(is.boolean(condition) && !condition.value)
       if (isTruthy) {
         return evaluateFormAsync(list.value[2], env, asyncCtx)
       }
       return list.value[3] !== undefined
         ? evaluateFormAsync(list.value[3], env, asyncCtx)
-        : cljNil()
+        : v.nil()
     }
 
     // let/let*: sequential bindings (value eval is async, pattern binding is sync)
-    case 'let':
-    case 'let*':
+    case specialFormKeywords.let:
       return evaluateLetAsync(list, env, asyncCtx)
 
     // loop: like let but supports recur
-    case 'loop':
+    case specialFormKeywords.loop:
       return evaluateLoopAsync(list, env, asyncCtx)
 
     // binding: evaluate binding values async, then body
-    case 'binding':
+    case specialFormKeywords.binding:
       return evaluateBindingAsync(list, env, asyncCtx)
 
     // try: evaluate body async, handle catch/finally async
-    case 'try':
+    case specialFormKeywords.try:
       return evaluateTryAsync(list, env, asyncCtx)
 
     // set!: evaluate new value async, then call sync set! logic
-    case 'set!': {
+    case specialFormKeywords['set!']: {
       // Re-delegate to sync ctx with the value already evaluated.
       // The sync set! handler will re-evaluate list.value[2] as a form —
       // that won't work with an already-evaluated value. So we call the sync
       // evaluator on a reconstructed list with the value quoted.
       const newVal = await evaluateFormAsync(list.value[2], env, asyncCtx)
-      const quotedVal: CljValue = {
-        kind: 'list',
-        value: [{ kind: 'symbol', name: 'quote' }, newVal],
-      }
-      const newList: CljValue = {
-        kind: 'list',
-        value: [list.value[0], list.value[1], quotedVal],
-      }
+      const quoted = v.list([v.symbol(specialFormKeywords.quote), newVal])
+      const newList = v.list([list.value[0], list.value[1], quoted])
       return asyncCtx.syncCtx.evaluate(newList, env)
     }
 
-    // quasiquote: delegate to sync — expansion is structural, no async sub-eval
-    case 'quasiquote':
-      return asyncCtx.syncCtx.evaluate(list, env)
-
-    // defmacro, defmulti, defmethod, letfn, delay, lazy-seq, async:
+    // defmacro, quasiquote, defmulti, defmethod, letfn, delay, lazy-seq, async:
     // delegate to sync evaluator (they don't have async sub-expressions in their
     // definition forms, or they create thunks that are evaluated sync later)
     default:
@@ -333,12 +321,12 @@ async function evaluateSpecialFormAsync(
 }
 
 async function evaluateLetAsync(
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
   const bindings = list.value[1]
-  validateBindingVector(bindings, 'let', env)
+  validateBindingVector(bindings, specialFormKeywords.let, env)
 
   let currentEnv = env
   const pairs = bindings.value
@@ -363,12 +351,12 @@ async function evaluateLetAsync(
 }
 
 async function evaluateLoopAsync(
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
   const loopBindings = list.value[1]
-  validateBindingVector(loopBindings, 'loop', env)
+  validateBindingVector(loopBindings, specialFormKeywords.loop, env)
 
   const loopBody = list.value.slice(2)
 
@@ -432,7 +420,7 @@ async function evaluateLoopAsync(
 }
 
 async function evaluateBindingAsync(
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
@@ -446,19 +434,16 @@ async function evaluateBindingAsync(
 }
 
 async function evaluateTryAsync(
-  list: { kind: 'list'; value: CljValue[] },
+  list: CljList,
   env: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
   // parseTryStructure validates catch/finally structure (binding symbol, ordering).
   // matchesDiscriminator uses asyncCtx.syncCtx — discriminator evaluation is always
   // synchronous (keyword checks, predicate calls on already-resolved values).
-  const { bodyForms, catchClauses, finallyForms } = parseTryStructure(
-    list as CljList,
-    env
-  )
+  const { bodyForms, catchClauses, finallyForms } = parseTryStructure(list, env)
 
-  let result: CljValue = cljNil()
+  let result: CljValue = v.nil()
   let pendingThrow: unknown = null
 
   try {
@@ -471,16 +456,10 @@ async function evaluateTryAsync(
       thrownValue = e.value
     } else if (e instanceof EvaluationError) {
       thrownValue = {
-        kind: 'map',
+        kind: valueKeywords.map,
         entries: [
-          [
-            { kind: 'keyword', name: ':type' },
-            { kind: 'keyword', name: ':error/runtime' },
-          ],
-          [
-            { kind: 'keyword', name: ':message' },
-            { kind: 'string', value: (e as Error).message },
-          ],
+          [v.keyword(':type'), v.keyword(':error/runtime')],
+          [v.keyword(':message'), v.string((e as Error).message)],
         ],
       }
     } else {
@@ -525,7 +504,7 @@ async function applyCallableAsync(
   callEnv: Env,
   asyncCtx: AsyncEvalCtx
 ): Promise<CljValue> {
-  if (fn.kind === 'native-function') {
+  if (is.nativeFunction(fn)) {
     // Native functions are sync — call as-is.
     // We do NOT auto-await CljPending results here: the caller is responsible
     // for awaiting (via @ deref interception or then/catch). This preserves
@@ -536,7 +515,7 @@ async function applyCallableAsync(
     return fn.fn(...args)
   }
 
-  if (fn.kind === 'function') {
+  if (is.function(fn)) {
     const arity = resolveArity(fn.arities, args.length)
     let currentArgs = args
     while (true) {

package/src/core/evaluator/collections.ts

@@ -1,13 +1,14 @@
-import { v } from '../factories'
 import { is } from '../assertions'
+import { v } from '../factories'
+import { valueKeywords } from '../keywords'
 import type {
   CljMap,
   CljSet,
   CljValue,
   CljVector,
+  Env,
   EvaluationContext,
 } from '../types'
-import type { Env } from '../types'
 
 export function evaluateVector(
   vector: CljVector,
@@ -16,7 +17,11 @@ export function evaluateVector(
 ): CljValue {
   const evaluated = vector.value.map((v) => ctx.evaluate(v, env))
   if (vector.meta)
-    return { kind: 'vector' as const, value: evaluated, meta: vector.meta }
+    return {
+      kind: valueKeywords.vector,
+      value: evaluated,
+      meta: vector.meta,
+    }
   return v.vector(evaluated)
 }
 
@@ -46,6 +51,6 @@ export function evaluateMap(
     const evaluatedValue = ctx.evaluate(value, env)
     entries.push([evaluatedKey, evaluatedValue])
   }
-  if (map.meta) return { kind: 'map' as const, entries, meta: map.meta }
+  if (map.meta) return { kind: valueKeywords.map, entries, meta: map.meta }
   return v.map(entries)
 }

package/src/core/evaluator/destructure.ts

@@ -1,14 +1,7 @@
 import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import {
-  cljKeyword,
-  cljList,
-  cljNil,
-  cljString,
-  cljSymbol,
-  v,
-} from '../factories'
-import { realizeLazySeq, consToArray } from '../transformations'
+import { v } from '../factories'
+import { consToArray, realizeLazySeq } from '../transformations'
 import type { CljMap, CljValue, Env, EvaluationContext } from '../types'
 
 function toSeqSafe(value: CljValue): CljValue[] {
@@ -28,7 +21,7 @@ function toSeqSafe(value: CljValue): CljValue[] {
 
 /** Return the first element of a seq-like value without full realization. */
 function seqFirst(value: CljValue): CljValue {
-  if (is.nil(value)) return cljNil()
+  if (is.nil(value)) return v.nil()
   if (is.lazySeq(value)) {
     const realized = realizeLazySeq(value)
     return is.nil(realized) ? v.nil() : seqFirst(realized)
@@ -88,9 +81,7 @@ function destructureVector(
   const elems = [...pattern]
 
   // :as alias — must appear as second-to-last with a symbol after it
-  const asIdx = elems.findIndex(
-    (e) => is.keyword(e) && e.kind === 'keyword' && e.name === ':as'
-  )
+  const asIdx = elems.findIndex((e) => is.keyword(e) && e.name === ':as')
   if (asIdx !== -1) {
     const asSym = elems[asIdx + 1]
     if (!asSym || !is.symbol(asSym)) {
@@ -131,7 +122,7 @@ function destructureVector(
         const restArgs = toSeqSafe(current)
         const entries: [CljValue, CljValue][] = []
         for (let i = 0; i < restArgs.length; i += 2) {
-          entries.push([restArgs[i], restArgs[i + 1] ?? cljNil()])
+          entries.push([restArgs[i], restArgs[i + 1] ?? v.nil()])
         }
         pairs.push(
           ...destructureBindings(
@@ -143,7 +134,7 @@ function destructureVector(
         )
       } else {
         // Keep the rest as-is (still lazy) — wrap in list only if it's nil/empty
-        const restValue = seqIsEmpty(current) ? cljNil() : current
+        const restValue = seqIsEmpty(current) ? v.nil() : current
         pairs.push(...destructureBindings(restPattern, restValue, ctx, env))
       }
     }
@@ -152,7 +143,7 @@ function destructureVector(
 
     // positional bindings
     for (let i = 0; i < positionalCount; i++) {
-      pairs.push(...destructureBindings(elems[i], seq[i] ?? cljNil(), ctx, env))
+      pairs.push(...destructureBindings(elems[i], seq[i] ?? v.nil(), ctx, env))
     }
 
     // rest binding
@@ -163,11 +154,11 @@ function destructureVector(
         // kwargs-style: coerce flat key-value pairs into a map
         const entries: [CljValue, CljValue][] = []
         for (let i = 0; i < restArgs.length; i += 2) {
-          entries.push([restArgs[i], restArgs[i + 1] ?? cljNil()])
+          entries.push([restArgs[i], restArgs[i + 1] ?? v.nil()])
         }
         restValue = { kind: 'map', entries }
       } else {
-        restValue = restArgs.length > 0 ? cljList(restArgs) : cljNil()
+        restValue = restArgs.length > 0 ? v.list(restArgs) : v.nil()
       }
       pairs.push(...destructureBindings(restPattern, restValue, ctx, env))
     }
@@ -184,33 +175,32 @@ function destructureMap(
 ): [string, CljValue][] {
   const pairs: [string, CljValue][] = []
 
-  const orMapVal = findMapEntry(pattern, cljKeyword(':or'))
+  const orMapVal = findMapEntry(pattern, v.keyword(':or'))
   const orMap = orMapVal && is.map(orMapVal) ? orMapVal : null
-  const asVal = findMapEntry(pattern, cljKeyword(':as'))
-
-  if (!is.map(value) && value.kind !== 'nil') {
+  const asVal = findMapEntry(pattern, v.keyword(':as'))
+  const isNil = is.nil(value)
+  if (!is.map(value) && !isNil) {
     throw new EvaluationError(`Cannot destructure ${value.kind} as a map`, {
       value,
       pattern,
     })
   }
 
-  const targetMap: CljMap =
-    value.kind === 'nil' ? { kind: 'map', entries: [] } : (value as CljMap)
+  const targetMap: CljMap = isNil ? v.map([]) : (value as CljMap)
 
-  for (const [k, v] of pattern.entries) {
-    if (is.keyword(k) && k.name === ':or') continue
-    if (is.keyword(k) && k.name === ':as') continue
+  for (const [key, val] of pattern.entries) {
+    if (is.keyword(key) && key.name === ':or') continue
+    if (is.keyword(key) && key.name === ':as') continue
 
     // :keys shorthand — lookup by keyword (supports qualified: ns/foo → :ns/foo, binds to foo)
-    if (is.keyword(k) && k.name === ':keys') {
-      if (!is.vector(v)) {
+    if (is.keyword(key) && key.name === ':keys') {
+      if (!is.vector(val)) {
         throw new EvaluationError(
           ':keys must be followed by a vector of symbols',
           { pattern }
         )
       }
-      for (const sym of v.value) {
+      for (const sym of val.value) {
         if (!is.symbol(sym)) {
           throw new EvaluationError(':keys vector must contain symbols', {
             pattern,
@@ -220,7 +210,7 @@ function destructureMap(
         const slashIdx = sym.name.indexOf('/')
         const localName =
           slashIdx !== -1 ? sym.name.slice(slashIdx + 1) : sym.name
-        const lookupKey = cljKeyword(':' + sym.name)
+        const lookupKey = v.keyword(':' + sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
         const entry = present ? findMapEntry(targetMap, lookupKey)! : undefined
 
@@ -228,11 +218,11 @@ function destructureMap(
         if (present) {
           result = entry!
         } else if (orMap) {
-          const orDefault = findMapEntry(orMap, cljSymbol(localName))
+          const orDefault = findMapEntry(orMap, v.symbol(localName))
           result =
-            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : v.nil()
         } else {
-          result = cljNil()
+          result = v.nil()
         }
         pairs.push([localName, result])
       }
@@ -240,21 +230,21 @@ function destructureMap(
     }
 
     // :strs shorthand — lookup by string
-    if (is.keyword(k) && k.name === ':strs') {
-      if (!is.vector(v)) {
+    if (is.keyword(key) && key.name === ':strs') {
+      if (!is.vector(val)) {
         throw new EvaluationError(
           ':strs must be followed by a vector of symbols',
           { pattern }
         )
       }
-      for (const sym of v.value) {
+      for (const sym of val.value) {
         if (!is.symbol(sym)) {
           throw new EvaluationError(':strs vector must contain symbols', {
             pattern,
             sym,
           })
         }
-        const lookupKey = cljString(sym.name)
+        const lookupKey = v.string(sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
         const entry = present ? findMapEntry(targetMap, lookupKey)! : undefined
 
@@ -262,11 +252,11 @@ function destructureMap(
         if (present) {
           result = entry!
         } else if (orMap) {
-          const orDefault = findMapEntry(orMap, cljSymbol(sym.name))
+          const orDefault = findMapEntry(orMap, v.symbol(sym.name))
           result =
-            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : v.nil()
         } else {
-          result = cljNil()
+          result = v.nil()
         }
         pairs.push([sym.name, result])
       }
@@ -274,21 +264,21 @@ function destructureMap(
     }
 
     // :syms shorthand — lookup by symbol
-    if (is.keyword(k) && k.name === ':syms') {
-      if (!is.vector(v)) {
+    if (is.keyword(key) && key.name === ':syms') {
+      if (!is.vector(val)) {
         throw new EvaluationError(
           ':syms must be followed by a vector of symbols',
           { pattern }
         )
       }
-      for (const sym of v.value) {
+      for (const sym of val.value) {
         if (!is.symbol(sym)) {
           throw new EvaluationError(':syms vector must contain symbols', {
             pattern,
             sym,
           })
         }
-        const lookupKey = cljSymbol(sym.name)
+        const lookupKey = v.symbol(sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
         const entry = present ? findMapEntry(targetMap, lookupKey)! : undefined
 
@@ -296,11 +286,11 @@ function destructureMap(
         if (present) {
           result = entry!
         } else if (orMap) {
-          const orDefault = findMapEntry(orMap, cljSymbol(sym.name))
+          const orDefault = findMapEntry(orMap, v.symbol(sym.name))
           result =
-            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : v.nil()
         } else {
-          result = cljNil()
+          result = v.nil()
         }
         pairs.push([sym.name, result])
       }
@@ -309,20 +299,20 @@ function destructureMap(
 
     // Regular entry: {local-pattern :lookup-key}
     // The key of the map entry is the binding pattern, the value is the lookup key
-    const entry = findMapEntry(targetMap, v)
-    const present = mapContainsKey(targetMap, v)
+    const entry = findMapEntry(targetMap, val)
+    const present = mapContainsKey(targetMap, val)
 
     let boundVal: CljValue
     if (present) {
       boundVal = entry!
-    } else if (orMap && is.symbol(k)) {
-      const orDefault = findMapEntry(orMap, cljSymbol(k.name))
+    } else if (orMap && is.symbol(key)) {
+      const orDefault = findMapEntry(orMap, v.symbol(key.name))
       boundVal =
-        orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+        orDefault !== undefined ? ctx.evaluate(orDefault, env) : v.nil()
     } else {
-      boundVal = cljNil()
+      boundVal = v.nil()
     }
-    pairs.push(...destructureBindings(k, boundVal, ctx, env))
+    pairs.push(...destructureBindings(key, boundVal, ctx, env))
   }
 
   // :as alias