conjure-js 0.0.12 → 0.0.13

package/src/core/evaluator/destructure.ts

@@ -1,28 +1,81 @@
-import { isEqual, isKeyword, isList, isMap, isSymbol, isVector } from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import { cljKeyword, cljList, cljNil, cljString, cljSymbol } from '../factories'
+import {
+  cljKeyword,
+  cljList,
+  cljNil,
+  cljString,
+  cljSymbol,
+  v,
+} from '../factories'
+import { realizeLazySeq, consToArray } from '../transformations'
 import type { CljMap, CljValue, Env, EvaluationContext } from '../types'
 
 function toSeqSafe(value: CljValue): CljValue[] {
-  if (value.kind === 'nil') return []
-  if (isList(value)) return value.value
-  if (isVector(value)) return value.value
+  if (is.nil(value)) return []
+  if (is.list(value)) return value.value
+  if (is.vector(value)) return value.value
+  if (is.lazySeq(value)) {
+    const realized = realizeLazySeq(value)
+    return toSeqSafe(realized)
+  }
+  if (is.cons(value)) return consToArray(value)
   throw new EvaluationError(
     `Cannot destructure ${value.kind} as a sequential collection`,
     { value }
   )
 }
 
-function findMapEntry(
-  map: CljMap,
-  key: CljValue
-): CljValue | undefined {
-  const entry = map.entries.find(([k]) => isEqual(k, key))
+/** 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.lazySeq(value)) {
+    const realized = realizeLazySeq(value)
+    return is.nil(realized) ? v.nil() : seqFirst(realized)
+  }
+  if (is.cons(value)) return value.head
+  if (is.list(value) || is.vector(value))
+    return value.value.length > 0 ? value.value[0] : v.nil()
+  return v.nil()
+}
+
+/** Return the tail of a seq-like value without full realization. */
+function seqRest(value: CljValue): CljValue {
+  if (is.nil(value)) return v.list([])
+  if (is.lazySeq(value)) {
+    const realized = realizeLazySeq(value)
+    return is.nil(realized) ? v.list([]) : seqRest(realized)
+  }
+  if (is.cons(value)) return value.tail
+  if (is.list(value)) return v.list(value.value.slice(1))
+  if (is.vector(value)) return v.list(value.value.slice(1))
+  return v.list([])
+}
+
+/** Check if a seq-like value is empty without full realization. */
+function seqIsEmpty(value: CljValue): boolean {
+  if (is.nil(value)) return true
+  if (is.lazySeq(value)) {
+    const realized = realizeLazySeq(value)
+    return seqIsEmpty(realized)
+  }
+  if (is.cons(value)) return false
+  if (is.list(value) || is.vector(value)) return value.value.length === 0
+  return true
+}
+
+/** Check if a value is lazy (lazy-seq or cons with lazy tail). */
+function isLazy(value: CljValue): boolean {
+  return is.lazySeq(value) || is.cons(value)
+}
+
+function findMapEntry(map: CljMap, key: CljValue): CljValue | undefined {
+  const entry = map.entries.find(([k]) => is.equal(k, key))
   return entry ? entry[1] : undefined
 }
 
 function mapContainsKey(map: CljMap, key: CljValue): boolean {
-  return map.entries.some(([k]) => isEqual(k, key))
+  return map.entries.some(([k]) => is.equal(k, key))
 }
 
 function destructureVector(
@@ -35,10 +88,12 @@ function destructureVector(
   const elems = [...pattern]
 
   // :as alias — must appear as second-to-last with a symbol after it
-  const asIdx = elems.findIndex((e) => isKeyword(e) && e.kind === 'keyword' && e.name === ':as')
+  const asIdx = elems.findIndex(
+    (e) => is.keyword(e) && e.kind === 'keyword' && e.name === ':as'
+  )
   if (asIdx !== -1) {
     const asSym = elems[asIdx + 1]
-    if (!asSym || !isSymbol(asSym)) {
+    if (!asSym || !is.symbol(asSym)) {
       throw new EvaluationError(':as must be followed by a symbol', { pattern })
     }
     pairs.push([asSym.name, value])
@@ -46,13 +101,15 @@ function destructureVector(
   }
 
   // & rest pattern
-  const ampIdx = elems.findIndex((e) => isSymbol(e) && e.name === '&')
+  const ampIdx = elems.findIndex((e) => is.symbol(e) && e.name === '&')
   let restPattern: CljValue | null = null
   let positionalCount: number
   if (ampIdx !== -1) {
     restPattern = elems[ampIdx + 1]
     if (!restPattern) {
-      throw new EvaluationError('& must be followed by a binding pattern', { pattern })
+      throw new EvaluationError('& must be followed by a binding pattern', {
+        pattern,
+      })
     }
     positionalCount = ampIdx
     elems.splice(ampIdx)
@@ -60,28 +117,60 @@ function destructureVector(
     positionalCount = elems.length
   }
 
-  const seq = toSeqSafe(value)
+  // For lazy seqs, walk with first/rest to avoid full realization.
+  // For eager collections, use flat array for efficiency.
+  if (isLazy(value)) {
+    let current: CljValue = value
+    for (let i = 0; i < positionalCount; i++) {
+      pairs.push(...destructureBindings(elems[i], seqFirst(current), ctx, env))
+      current = seqRest(current)
+    }
+    if (restPattern !== null) {
+      // For kwargs-style map destructuring on rest, we must realize
+      if (is.map(restPattern) && !seqIsEmpty(current)) {
+        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()])
+        }
+        pairs.push(
+          ...destructureBindings(
+            restPattern,
+            { kind: 'map', entries },
+            ctx,
+            env
+          )
+        )
+      } else {
+        // Keep the rest as-is (still lazy) — wrap in list only if it's nil/empty
+        const restValue = seqIsEmpty(current) ? cljNil() : current
+        pairs.push(...destructureBindings(restPattern, restValue, ctx, env))
+      }
+    }
+  } else {
+    const seq = toSeqSafe(value)
 
-  // positional bindings
-  for (let i = 0; i < positionalCount; i++) {
-    pairs.push(...destructureBindings(elems[i], seq[i] ?? cljNil(), ctx, env))
-  }
+    // positional bindings
+    for (let i = 0; i < positionalCount; i++) {
+      pairs.push(...destructureBindings(elems[i], seq[i] ?? cljNil(), ctx, env))
+    }
 
-  // rest binding
-  if (restPattern !== null) {
-    const restArgs = seq.slice(positionalCount)
-    let restValue: CljValue
-    if (isMap(restPattern) && restArgs.length > 0) {
-      // 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()])
+    // rest binding
+    if (restPattern !== null) {
+      const restArgs = seq.slice(positionalCount)
+      let restValue: CljValue
+      if (is.map(restPattern) && restArgs.length > 0) {
+        // 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()])
+        }
+        restValue = { kind: 'map', entries }
+      } else {
+        restValue = restArgs.length > 0 ? cljList(restArgs) : cljNil()
       }
-      restValue = { kind: 'map', entries }
-    } else {
-      restValue = restArgs.length > 0 ? cljList(restArgs) : cljNil()
+      pairs.push(...destructureBindings(restPattern, restValue, ctx, env))
     }
-    pairs.push(...destructureBindings(restPattern, restValue, ctx, env))
   }
 
   return pairs
@@ -96,35 +185,41 @@ function destructureMap(
   const pairs: [string, CljValue][] = []
 
   const orMapVal = findMapEntry(pattern, cljKeyword(':or'))
-  const orMap = orMapVal && isMap(orMapVal) ? orMapVal : null
+  const orMap = orMapVal && is.map(orMapVal) ? orMapVal : null
   const asVal = findMapEntry(pattern, cljKeyword(':as'))
 
-  if (!isMap(value) && value.kind !== 'nil') {
-    throw new EvaluationError(
-      `Cannot destructure ${value.kind} as a map`,
-      { value, pattern }
-    )
+  if (!is.map(value) && value.kind !== 'nil') {
+    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 =
+    value.kind === 'nil' ? { kind: 'map', entries: [] } : (value as CljMap)
 
   for (const [k, v] of pattern.entries) {
-    if (isKeyword(k) && k.name === ':or') continue
-    if (isKeyword(k) && k.name === ':as') continue
+    if (is.keyword(k) && k.name === ':or') continue
+    if (is.keyword(k) && k.name === ':as') continue
 
     // :keys shorthand — lookup by keyword (supports qualified: ns/foo → :ns/foo, binds to foo)
-    if (isKeyword(k) && k.name === ':keys') {
-      if (!isVector(v)) {
-        throw new EvaluationError(':keys must be followed by a vector of symbols', { pattern })
+    if (is.keyword(k) && k.name === ':keys') {
+      if (!is.vector(v)) {
+        throw new EvaluationError(
+          ':keys must be followed by a vector of symbols',
+          { pattern }
+        )
       }
       for (const sym of v.value) {
-        if (!isSymbol(sym)) {
-          throw new EvaluationError(':keys vector must contain symbols', { pattern, sym })
+        if (!is.symbol(sym)) {
+          throw new EvaluationError(':keys vector must contain symbols', {
+            pattern,
+            sym,
+          })
         }
         const slashIdx = sym.name.indexOf('/')
-        const localName = slashIdx !== -1 ? sym.name.slice(slashIdx + 1) : sym.name
+        const localName =
+          slashIdx !== -1 ? sym.name.slice(slashIdx + 1) : sym.name
         const lookupKey = cljKeyword(':' + sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
         const entry = present ? findMapEntry(targetMap, lookupKey)! : undefined
@@ -134,7 +229,8 @@ function destructureMap(
           result = entry!
         } else if (orMap) {
           const orDefault = findMapEntry(orMap, cljSymbol(localName))
-          result = orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+          result =
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
         } else {
           result = cljNil()
         }
@@ -144,13 +240,19 @@ function destructureMap(
     }
 
     // :strs shorthand — lookup by string
-    if (isKeyword(k) && k.name === ':strs') {
-      if (!isVector(v)) {
-        throw new EvaluationError(':strs must be followed by a vector of symbols', { pattern })
+    if (is.keyword(k) && k.name === ':strs') {
+      if (!is.vector(v)) {
+        throw new EvaluationError(
+          ':strs must be followed by a vector of symbols',
+          { pattern }
+        )
       }
       for (const sym of v.value) {
-        if (!isSymbol(sym)) {
-          throw new EvaluationError(':strs vector must contain symbols', { pattern, sym })
+        if (!is.symbol(sym)) {
+          throw new EvaluationError(':strs vector must contain symbols', {
+            pattern,
+            sym,
+          })
         }
         const lookupKey = cljString(sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
@@ -161,7 +263,8 @@ function destructureMap(
           result = entry!
         } else if (orMap) {
           const orDefault = findMapEntry(orMap, cljSymbol(sym.name))
-          result = orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+          result =
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
         } else {
           result = cljNil()
         }
@@ -171,13 +274,19 @@ function destructureMap(
     }
 
     // :syms shorthand — lookup by symbol
-    if (isKeyword(k) && k.name === ':syms') {
-      if (!isVector(v)) {
-        throw new EvaluationError(':syms must be followed by a vector of symbols', { pattern })
+    if (is.keyword(k) && k.name === ':syms') {
+      if (!is.vector(v)) {
+        throw new EvaluationError(
+          ':syms must be followed by a vector of symbols',
+          { pattern }
+        )
       }
       for (const sym of v.value) {
-        if (!isSymbol(sym)) {
-          throw new EvaluationError(':syms vector must contain symbols', { pattern, sym })
+        if (!is.symbol(sym)) {
+          throw new EvaluationError(':syms vector must contain symbols', {
+            pattern,
+            sym,
+          })
         }
         const lookupKey = cljSymbol(sym.name)
         const present = mapContainsKey(targetMap, lookupKey)
@@ -188,7 +297,8 @@ function destructureMap(
           result = entry!
         } else if (orMap) {
           const orDefault = findMapEntry(orMap, cljSymbol(sym.name))
-          result = orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+          result =
+            orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
         } else {
           result = cljNil()
         }
@@ -205,9 +315,10 @@ function destructureMap(
     let boundVal: CljValue
     if (present) {
       boundVal = entry!
-    } else if (orMap && isSymbol(k)) {
+    } else if (orMap && is.symbol(k)) {
       const orDefault = findMapEntry(orMap, cljSymbol(k.name))
-      boundVal = orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
+      boundVal =
+        orDefault !== undefined ? ctx.evaluate(orDefault, env) : cljNil()
     } else {
       boundVal = cljNil()
     }
@@ -215,7 +326,7 @@ function destructureMap(
   }
 
   // :as alias
-  if (asVal && isSymbol(asVal)) {
+  if (asVal && is.symbol(asVal)) {
     pairs.push([asVal.name, value])
   }
 
@@ -228,15 +339,15 @@ export function destructureBindings(
   ctx: EvaluationContext,
   env: Env
 ): [string, CljValue][] {
-  if (isSymbol(pattern)) {
+  if (is.symbol(pattern)) {
     return [[pattern.name, value]]
   }
 
-  if (isVector(pattern)) {
+  if (is.vector(pattern)) {
     return destructureVector(pattern.value, value, ctx, env)
   }
 
-  if (isMap(pattern)) {
+  if (is.map(pattern)) {
     return destructureMap(pattern, value, ctx, env)
   }
 

package/src/core/evaluator/dispatch.ts

@@ -1,10 +1,4 @@
-import {
-  isCallable,
-  isEqual,
-  isMultiMethod,
-  isSpecialForm,
-  isSymbol,
-} from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
 import { printString } from '../printer'
 import { getPos } from '../positions'
@@ -26,7 +20,7 @@ function dispatchMultiMethod(
 ): CljValue {
   const dispatchVal = ctx.applyFunction(mm.dispatchFn, args, env)
   const method = mm.methods.find(({ dispatchVal: dv }) =>
-    isEqual(dv, dispatchVal)
+    is.equal(dv, dispatchVal)
   )
   if (method) return ctx.applyFunction(method.fn, args, env)
   if (mm.defaultMethod) return ctx.applyFunction(mm.defaultMethod, args, env)
@@ -49,23 +43,23 @@ export function evaluateList(
   ctx: EvaluationContext
 ): CljValue {
   if (list.value.length === 0) {
-    throw new EvaluationError('Unexpected empty list', { list, env })
+    return list
   }
   const first = list.value[0]
 
-  if (isSpecialForm(first)) {
+  if (is.specialForm(first)) {
     return evaluateSpecialForm(first.name, list, env, ctx)
   }
 
   const evaledFirst = ctx.evaluate(first, env)
 
-  if (isMultiMethod(evaledFirst)) {
+  if (is.multiMethod(evaledFirst)) {
     const args = list.value.slice(1).map((v) => ctx.evaluate(v, env))
     return dispatchMultiMethod(evaledFirst, args, ctx, env)
   }
 
-  if (!isCallable(evaledFirst)) {
-    const name = isSymbol(first) ? first.name : printString(first)
+  if (!is.callable(evaledFirst)) {
+    const name = is.symbol(first) ? first.name : printString(first)
     throw new EvaluationError(`${name} is not callable`, { list, env })
   }
 
@@ -73,7 +67,11 @@ export function evaluateList(
   try {
     return ctx.applyCallable(evaledFirst, args, env)
   } catch (e) {
-    if (e instanceof EvaluationError && e.data?.argIndex !== undefined && !e.pos) {
+    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)

package/src/core/evaluator/evaluate.ts

@@ -1,11 +1,11 @@
-import { getNamespaceEnv, getRootEnv, lookup } from '../env'
+import { derefValue, getNamespaceEnv, lookup } from '../env'
 import { EvaluationError } from '../errors'
-import { cljNil } from '../factories'
+import { v } from '../factories'
 import { getPos } from '../positions'
 import { valueKeywords } from '../types'
 
 import type { CljValue, Env, EvaluationContext } from '../types'
-import { evaluateMap, evaluateVector } from './collections'
+import { evaluateMap, evaluateSet, evaluateVector } from './collections'
 import { evaluateList } from './dispatch'
 
 export type EvaluationMeasurement = {
@@ -34,6 +34,10 @@ export function evaluateWithContext(
       case valueKeywords.multiMethod:
       case valueKeywords.boolean:
       case valueKeywords.regex:
+      case valueKeywords.delay:
+      case valueKeywords.lazySeq:
+      case valueKeywords.cons:
+      case valueKeywords.namespace:
         return expr
       case valueKeywords.symbol: {
         const slashIdx = expr.name.indexOf('/')
@@ -41,27 +45,23 @@ export function evaluateWithContext(
           const alias = expr.name.slice(0, slashIdx)
           const sym = expr.name.slice(slashIdx + 1)
           const nsEnv = getNamespaceEnv(env)
-          // Try alias lookup (CljNamespace) first
-          const aliasCljNs = nsEnv.ns?.aliases.get(alias)
-          if (aliasCljNs) {
-            const v = aliasCljNs.vars.get(sym)
-            if (v === undefined) {
-              throw new EvaluationError(`Symbol ${expr.name} not found`, {
-                symbol: expr.name,
-                env,
-              })
-            }
-            return v.value
-          }
-          // Fall back to full namespace Env chain (handles clojure.core/sym etc.)
-          const targetEnv = getRootEnv(env).resolveNs?.(alias) ?? null
-          if (!targetEnv) {
+          // Resolve alias: local :as alias first, then full namespace name
+          const targetNs =
+            nsEnv.ns?.aliases.get(alias) ?? ctx.resolveNs(alias) ?? null
+          if (!targetNs) {
             throw new EvaluationError(`No such namespace or alias: ${alias}`, {
               symbol: expr.name,
               env,
             })
           }
-          return lookup(sym, targetEnv)
+          const v = targetNs.vars.get(sym)
+          if (v === undefined) {
+            throw new EvaluationError(`Symbol ${expr.name} not found`, {
+              symbol: expr.name,
+              env,
+            })
+          }
+          return derefValue(v)
         }
         return lookup(expr.name, env)
       }
@@ -69,6 +69,8 @@ export function evaluateWithContext(
         return evaluateVector(expr, env, ctx)
       case valueKeywords.map:
         return evaluateMap(expr, env, ctx)
+      case valueKeywords.set:
+        return evaluateSet(expr, env, ctx)
       case valueKeywords.list:
         return evaluateList(expr, env, ctx)
       default:
@@ -88,7 +90,7 @@ export function evaluateFormsWithContext(
   env: Env,
   ctx: EvaluationContext
 ): CljValue {
-  let result: CljValue = cljNil()
+  let result: CljValue = v.nil()
   for (const form of forms) {
     result = ctx.evaluate(form, env)
   }

package/src/core/evaluator/expand.ts

@@ -1,5 +1,5 @@
-import { isList, isMap, isMacro, isSymbol, isVector } from '../assertions'
-import { tryLookup } from '../env'
+import { is } from '../assertions'
+import { derefValue, getNamespaceEnv, tryLookup } from '../env'
 import { cljList, cljMap, cljVector } from '../factories'
 import type { CljValue, Env, EvaluationContext } from '../types'
 
@@ -25,13 +25,17 @@ export function macroExpandAllWithContext(
   ctx: EvaluationContext
 ): CljValue {
   // Vectors: expand each element (covers [x (some-macro ...)] in let bindings etc.)
-  if (isVector(form)) {
-    const expanded = form.value.map((sub) => macroExpandAllWithContext(sub, env, ctx))
-    return expanded.every((e, i) => e === form.value[i]) ? form : cljVector(expanded)
+  if (is.vector(form)) {
+    const expanded = form.value.map((sub) =>
+      macroExpandAllWithContext(sub, env, ctx)
+    )
+    return expanded.every((e, i) => e === form.value[i])
+      ? form
+      : cljVector(expanded)
   }
 
   // Maps: expand each key and value
-  if (isMap(form)) {
+  if (is.map(form)) {
     const expanded = form.entries.map(
       ([k, v]) =>
         [
@@ -39,13 +43,15 @@ export function macroExpandAllWithContext(
           macroExpandAllWithContext(v, env, ctx),
         ] as [CljValue, CljValue]
     )
-    return expanded.every(([k, v], i) => k === form.entries[i][0] && v === form.entries[i][1])
+    return expanded.every(
+      ([k, v], i) => k === form.entries[i][0] && v === form.entries[i][1]
+    )
       ? form
       : cljMap(expanded)
   }
 
   // Atoms (number, string, boolean, keyword, nil, symbol, regex, functions, etc.)
-  if (!isList(form)) return form
+  if (!is.list(form)) return form
 
   // Empty list
   if (form.value.length === 0) return form
@@ -53,9 +59,13 @@ export function macroExpandAllWithContext(
   const first = form.value[0]
 
   // Non-symbol head (e.g. anonymous fn call `((fn [x] x) 5)`): expand all sub-forms
-  if (!isSymbol(first)) {
-    const expanded = form.value.map((sub) => macroExpandAllWithContext(sub, env, ctx))
-    return expanded.every((e, i) => e === form.value[i]) ? form : cljList(expanded)
+  if (!is.symbol(first)) {
+    const expanded = form.value.map((sub) =>
+      macroExpandAllWithContext(sub, env, ctx)
+    )
+    return expanded.every((e, i) => e === form.value[i])
+      ? form
+      : cljList(expanded)
   }
 
   const name = first.name
@@ -66,14 +76,34 @@ export function macroExpandAllWithContext(
   // Check whether the head resolves to a macro in the current env.
   // tryLookup returns undefined for unknown symbols (forward refs, fn params, etc.)
   // avoiding the try/catch exception path entirely.
-  const macroOrUnknown = tryLookup(name, env)
-  if (macroOrUnknown !== undefined && isMacro(macroOrUnknown)) {
+  // For qualified symbols like clojure.core/when-let or aliased m/my-macro,
+  // resolve via local :as alias first, then full namespace name.
+  let macroOrUnknown: CljValue | undefined
+  const slashIdx = name.indexOf('/')
+  if (slashIdx > 0 && slashIdx < name.length - 1) {
+    const nsPrefix = name.slice(0, slashIdx)
+    const localName = name.slice(slashIdx + 1)
+    const nsEnv = getNamespaceEnv(env)
+    const targetNs =
+      nsEnv.ns?.aliases.get(nsPrefix) ?? ctx.resolveNs(nsPrefix) ?? null
+    if (targetNs) {
+      const v = targetNs.vars.get(localName)
+      macroOrUnknown = v !== undefined ? derefValue(v) : undefined
+    }
+  } else {
+    macroOrUnknown = tryLookup(name, env)
+  }
+  if (macroOrUnknown !== undefined && is.macro(macroOrUnknown)) {
     const expanded = ctx.applyMacro(macroOrUnknown, form.value.slice(1))
     // Keep expanding until no more macros at the top level
     return macroExpandAllWithContext(expanded, env, ctx)
   }
 
   // Special forms and function calls: expand all sub-forms
-  const expanded = form.value.map((sub) => macroExpandAllWithContext(sub, env, ctx))
-  return expanded.every((e, i) => e === form.value[i]) ? form : cljList(expanded)
+  const expanded = form.value.map((sub) =>
+    macroExpandAllWithContext(sub, env, ctx)
+  )
+  return expanded.every((e, i) => e === form.value[i])
+    ? form
+    : cljList(expanded)
 }