conjure-js 0.0.11 → 0.0.13

package/src/core/printer.ts

@@ -1,7 +1,116 @@
 import { EvaluationError } from './errors'
-import { valueKeywords, type CljMultiMethod, type CljValue } from './types'
+import type { CljCons, CljLazySeq } from './types'
+import { valueKeywords, type CljMultiMethod, type CljValue, type EvaluationContext } from './types'
+import { derefValue } from './env'
 
-export function printString(value: CljValue): string {
+const LAZY_PRINT_CAP = 100
+
+/** Realize a lazy-seq (local copy to avoid circular dep with transformations). */
+function realizeLazy(ls: CljLazySeq): CljValue {
+  let current: CljValue = ls
+  while (current.kind === 'lazy-seq') {
+    const lazy = current as CljLazySeq
+    if (lazy.realized) { current = lazy.value!; continue }
+    if (lazy.thunk) {
+      lazy.value = lazy.thunk()
+      lazy.thunk = null
+      lazy.realized = true
+      current = lazy.value!
+    } else {
+      return { kind: 'nil', value: null }
+    }
+  }
+  return current
+}
+
+/** Walk a lazy/cons chain collecting up to `limit` elements for printing. */
+function collectSeqElements(value: CljValue, limit: number, depth: number): { items: string[]; truncated: boolean } {
+  const items: string[] = []
+  let current = value
+  while (items.length < limit) {
+    if (current.kind === 'nil') break
+    if (current.kind === 'lazy-seq') {
+      current = realizeLazy(current as CljLazySeq)
+      continue
+    }
+    if (current.kind === 'cons') {
+      const c = current as CljCons
+      items.push(printString(c.head, depth + 1))
+      current = c.tail
+      continue
+    }
+    if (current.kind === 'list') {
+      for (const v of current.value) {
+        if (items.length >= limit) break
+        items.push(printString(v, depth + 1))
+      }
+      break
+    }
+    if (current.kind === 'vector') {
+      for (const v of current.value) {
+        if (items.length >= limit) break
+        items.push(printString(v, depth + 1))
+      }
+      break
+    }
+    // Unknown tail — just print it
+    items.push(printString(current, depth + 1))
+    break
+  }
+  return { items, truncated: items.length >= limit }
+}
+
+// --- Print context (*print-length* / *print-level*) ---
+// Single-threaded JS: module-level state is safe.
+export interface PrintContext {
+  printLength: number | null
+  printLevel: number | null
+}
+
+let _printCtx: PrintContext = { printLength: null, printLevel: null }
+
+export function getPrintContext(): PrintContext { return _printCtx }
+
+export function withPrintContext<T>(ctx: PrintContext, fn: () => T): T {
+  const prev = _printCtx
+  _printCtx = ctx
+  try {
+    return fn()
+  } finally {
+    _printCtx = prev
+  }
+}
+
+/**
+ * Build a PrintContext by reading *print-length* and *print-level* from the
+ * runtime registry via ctx.resolveNs. Use this (instead of tryLookup) so that
+ * dynamic bindings from inside Clojure function bodies are visible even after
+ * a snapshot restore (where closure envs are stale).
+ */
+export function buildPrintContext(ctx: EvaluationContext): PrintContext {
+  const lenVar = ctx.resolveNs('clojure.core')?.vars.get('*print-length*')
+  const lvlVar = ctx.resolveNs('clojure.core')?.vars.get('*print-level*')
+  const len = lenVar ? derefValue(lenVar) : undefined
+  const level = lvlVar ? derefValue(lvlVar) : undefined
+  return {
+    printLength: len?.kind === 'number' ? len.value : null,
+    printLevel: level?.kind === 'number' ? level.value : null,
+  }
+}
+
+export function printString(value: CljValue, _depth = 0): string {
+  const { printLevel } = _printCtx
+  if (printLevel !== null && _depth >= printLevel) {
+    if (
+      value.kind === 'list' || value.kind === 'vector' ||
+      value.kind === 'map' || value.kind === 'set' ||
+      value.kind === 'cons' || value.kind === 'lazy-seq'
+    ) return '#'
+  }
+  return printStringImpl(value, _depth)
+}
+
+function printStringImpl(value: CljValue, depth: number): string {
   switch (value.kind) {
     case valueKeywords.number:
       return value.value.toString()
@@ -37,12 +146,24 @@ export function printString(value: CljValue): string {
       return `${value.name}`
     case valueKeywords.symbol:
       return `${value.name}`
-    case valueKeywords.list:
-      return `(${value.value.map(printString).join(' ')})`
-    case valueKeywords.vector:
-      return `[${value.value.map(printString).join(' ')}]`
-    case valueKeywords.map:
-      return `{${value.entries.map(([key, value]) => `${printString(key)} ${printString(value)}`).join(' ')}}`
+    case valueKeywords.list: {
+      const { printLength } = _printCtx
+      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `(${items.map(v => printString(v, depth + 1)).join(' ')}${suffix})`
+    }
+    case valueKeywords.vector: {
+      const { printLength } = _printCtx
+      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `[${items.map(v => printString(v, depth + 1)).join(' ')}${suffix}]`
+    }
+    case valueKeywords.map: {
+      const { printLength } = _printCtx
+      const entries = printLength !== null ? value.entries.slice(0, printLength) : value.entries
+      const suffix = printLength !== null && value.entries.length > printLength ? ' ...' : ''
+      return `{${entries.map(([key, v]) => `${printString(key, depth + 1)} ${printString(v, depth + 1)}`).join(' ')}${suffix}}`
+    }
     case valueKeywords.function: {
       if (value.arities.length === 1) {
         const a = value.arities[0]
@@ -64,11 +185,11 @@ export function printString(value: CljValue): string {
     case valueKeywords.multiMethod:
       return `(multi-method ${(value as CljMultiMethod).name})`
     case valueKeywords.atom:
-      return `#<Atom ${printString(value.value)}>`
+      return `#<Atom ${printString(value.value, depth + 1)}>`
     case valueKeywords.reduced:
-      return `#<Reduced ${printString(value.value)}>`
+      return `#<Reduced ${printString(value.value, depth + 1)}>`
     case valueKeywords.volatile:
-      return `#<Volatile ${printString(value.value)}>`
+      return `#<Volatile ${printString(value.value, depth + 1)}>`
     case valueKeywords.regex: {
       const escaped = value.pattern.replace(/"/g, '\\"')
       const prefix = value.flags ? `(?${value.flags})` : ''
@@ -76,6 +197,49 @@ export function printString(value: CljValue): string {
     }
     case valueKeywords.var:
       return `#'${value.ns}/${value.name}`
+    case valueKeywords.set: {
+      const { printLength } = _printCtx
+      const items = printLength !== null ? value.values.slice(0, printLength) : value.values
+      const suffix = printLength !== null && value.values.length > printLength ? ' ...' : ''
+      return `#{${items.map(v => printString(v, depth + 1)).join(' ')}${suffix}}`
+    }
+    case valueKeywords.delay:
+      if (value.realized) return `#<Delay @${printString(value.value!, depth + 1)}>`
+      return '#<Delay pending>'
+    case valueKeywords.lazySeq:
+    case valueKeywords.cons: {
+      const { printLength } = _printCtx
+      const limit = printLength !== null ? printLength : LAZY_PRINT_CAP
+      const { items, truncated } = collectSeqElements(value, limit, depth)
+      const suffix = truncated ? ' ...' : ''
+      return `(${items.join(' ')}${suffix})`
+    }
+    case valueKeywords.namespace:
+      return `#namespace[${value.name}]`
+    // --- ASYNC (experimental) ---
+    case 'pending':
+      if (value.resolved && value.resolvedValue !== undefined)
+        return `#<Pending @${printString(value.resolvedValue, depth + 1)}>`
+      return '#<Pending>'
+    // --- END ASYNC ---
+    case valueKeywords.jsValue: {
+      const raw = value.value
+      let typeName: string
+      if (raw === null) {
+        typeName = 'null'
+      } else if (raw === undefined) {
+        typeName = 'undefined'
+      } else if (typeof raw === 'function') {
+        typeName = 'Function'
+      } else if (Array.isArray(raw)) {
+        typeName = 'Array'
+      } else if (raw instanceof Promise) {
+        typeName = 'Promise'
+      } else {
+        typeName = (raw as { constructor?: { name?: string } }).constructor?.name ?? 'Object'
+      }
+      return `#<js ${typeName}>`
+    }
     default:
       throw new EvaluationError(`unhandled value type: ${value.kind}`, {
         value,
@@ -86,3 +250,199 @@ export function printString(value: CljValue): string {
 export function joinLines(lines: string[]): string {
   return lines.join('\n')
 }
+
+// --- Pretty printer ---
+
+// Known "body" forms: value is the number of "header" args kept on the first line.
+// Remaining args are indented 2 spaces from the opening paren.
+const BODY_FORM_HEADER_COUNT: Record<string, number> = {
+  // 0-header: entire body is indented
+  do: 0, try: 0, and: 0, or: 0, cond: 0, '->': 0, '->>': 0, 'some->': 0, 'some->>': 0,
+  // 1-header: one leading arg kept on first line (condition / binding vec / value)
+  when: 1, 'when-not': 1, 'when-let': 1, 'when-some': 1, 'when-first': 1,
+  if: 1, 'if-not': 1, 'if-let': 1, 'if-some': 1, while: 1,
+  let: 1, loop: 1, binding: 1, 'with-open': 1, 'with-local-vars': 1, locking: 1,
+  fn: 1, 'fn*': 1,
+  def: 1, defonce: 1, ns: 1,
+  doseq: 1, dotimes: 1, for: 1,
+  case: 1, 'cond->': 1, 'cond->>': 1,
+  // 2-header: name + params/dispatch on first line
+  defn: 2, 'defn-': 2, defmacro: 2, defmethod: 2,
+}
+
+// Forms whose first header arg (binding vector) should be printed as pairs.
+const BINDING_FORMS = new Set([
+  'let', 'loop', 'binding', 'with-open', 'for', 'doseq', 'dotimes',
+])
+
+// Forms whose body args are pairs (test expr, test expr, ...).
+const PAIR_BODY_FORMS = new Set(['cond', 'condp', 'case', 'cond->', 'cond->>'])
+
+function sp(n: number): string {
+  return n > 0 ? ' '.repeat(n) : ''
+}
+
+function lastLineLen(s: string): number {
+  const nl = s.lastIndexOf('\n')
+  return nl === -1 ? s.length : s.length - nl - 1
+}
+
+function pp(value: CljValue, col: number, maxWidth: number): string {
+  const flat = printString(value)
+  if (col + flat.length <= maxWidth) return flat
+
+  switch (value.kind) {
+    case valueKeywords.list:
+      return ppList(value.value, col, maxWidth)
+    case valueKeywords.vector:
+      return ppVec(value.value, col, maxWidth, false)
+    case valueKeywords.map:
+      return ppMap(value.entries, col, maxWidth)
+    case valueKeywords.set:
+      return ppSet(value.values, col, maxWidth)
+    case valueKeywords.lazySeq:
+    case valueKeywords.cons:
+      // Flat representation is already computed above; no deeper pretty-print needed
+      return flat
+    default:
+      return flat
+  }
+}
+
+function ppList(items: CljValue[], col: number, maxWidth: number): string {
+  if (items.length === 0) return '()'
+
+  const [head, ...args] = items
+  const headStr = printString(head)
+  const name = head.kind === valueKeywords.symbol ? head.name : null
+
+  // --- Known body form ---
+  if (name !== null && name in BODY_FORM_HEADER_COUNT) {
+    const hCount = BODY_FORM_HEADER_COUNT[name]
+    const headerArgs = args.slice(0, hCount)
+    const bodyArgs = args.slice(hCount)
+    const bodyIndent = col + 2
+
+    // Build header line: "(name headerArg0 headerArg1 ...)"
+    let result = '(' + headStr
+    let curCol = col + 1 + headStr.length
+
+    for (let i = 0; i < headerArgs.length; i++) {
+      const arg = headerArgs[i]
+      const argCol = curCol + 1
+      const isPairVec = BINDING_FORMS.has(name) && i === 0 && arg.kind === valueKeywords.vector
+      const argStr = isPairVec
+        ? ppVec((arg as Extract<CljValue, { kind: 'vector' }>).value, argCol, maxWidth, true)
+        : pp(arg, argCol, maxWidth)
+      result += ' ' + argStr
+      curCol = argStr.includes('\n') ? lastLineLen(argStr) : argCol + argStr.length - 1
+    }
+
+    if (bodyArgs.length === 0) return result + ')'
+
+    const bodyStr = PAIR_BODY_FORMS.has(name)
+      ? ppPairs(bodyArgs, bodyIndent, maxWidth)
+      : bodyArgs.map(a => sp(bodyIndent) + pp(a, bodyIndent, maxWidth)).join('\n')
+
+    return result + '\n' + bodyStr + ')'
+  }
+
+  // --- General case: flow or 2-space indent ---
+  if (args.length === 0) return '(' + headStr + ')'
+
+  const firstArgCol = col + 1 + headStr.length + 1
+
+  if (args.length === 1) {
+    return '(' + headStr + ' ' + pp(args[0], firstArgCol, maxWidth) + ')'
+  }
+
+  // For short head names: align subsequent args with the first arg.
+  // For long head names: fall back to 2-space indent for all args.
+  const argIndent = headStr.length <= 10 ? firstArgCol : col + 2
+  const argStrs = args.map(a => pp(a, argIndent, maxWidth))
+
+  if (argIndent === firstArgCol) {
+    return (
+      '(' + headStr + ' ' + argStrs[0] + '\n' +
+      argStrs.slice(1).map(s => sp(argIndent) + s).join('\n') + ')'
+    )
+  }
+  return '(' + headStr + '\n' + argStrs.map(s => sp(argIndent) + s).join('\n') + ')'
+}
+
+function ppVec(items: CljValue[], col: number, maxWidth: number, pairMode: boolean): string {
+  if (items.length === 0) return '[]'
+
+  const innerCol = col + 1
+
+  if (pairMode) {
+    const lines: string[] = []
+    for (let i = 0; i < items.length; i += 2) {
+      const prefix = i === 0 ? '' : sp(innerCol)
+      const keyFlat = printString(items[i])
+      if (i + 1 >= items.length) {
+        lines.push(prefix + keyFlat)
+        continue
+      }
+      const val = items[i + 1]
+      const pairFlat = keyFlat + ' ' + printString(val)
+      if (innerCol + pairFlat.length <= maxWidth) {
+        lines.push(prefix + pairFlat)
+      } else {
+        const valStr = pp(val, innerCol + keyFlat.length + 1, maxWidth)
+        lines.push(prefix + keyFlat + ' ' + valStr)
+      }
+    }
+    return '[' + lines.join('\n') + ']'
+  }
+
+  const strs = items.map((item, i) => {
+    const s = pp(item, innerCol, maxWidth)
+    return (i === 0 ? '' : sp(innerCol)) + s
+  })
+  return '[' + strs.join('\n') + ']'
+}
+
+function ppMap(entries: [CljValue, CljValue][], col: number, maxWidth: number): string {
+  if (entries.length === 0) return '{}'
+  const innerCol = col + 1
+  const pairs = entries.map(([k, v], i) => {
+    const kStr = printString(k)
+    const vStr = pp(v, innerCol + kStr.length + 1, maxWidth)
+    return (i === 0 ? '' : sp(innerCol)) + kStr + ' ' + vStr
+  })
+  return '{' + pairs.join('\n') + '}'
+}
+
+function ppSet(items: CljValue[], col: number, maxWidth: number): string {
+  if (items.length === 0) return '#{}'
+  const innerCol = col + 2 // '#{'
+  const strs = items.map((item, i) => {
+    const s = pp(item, innerCol, maxWidth)
+    return (i === 0 ? '' : sp(innerCol)) + s
+  })
+  return '#{' + strs.join('\n') + '}'
+}
+
+function ppPairs(items: CljValue[], indent: number, maxWidth: number): string {
+  const lines: string[] = []
+  for (let i = 0; i < items.length; i += 2) {
+    const testStr = pp(items[i], indent, maxWidth)
+    if (i + 1 >= items.length) {
+      lines.push(sp(indent) + testStr)
+      continue
+    }
+    const exprFlat = printString(items[i + 1])
+    const pairFlat = testStr + ' ' + exprFlat
+    if (indent + pairFlat.length <= maxWidth) {
+      lines.push(sp(indent) + pairFlat)
+    } else {
+      lines.push(sp(indent) + testStr + '\n' + sp(indent + 2) + pp(items[i + 1], indent + 2, maxWidth))
+    }
+  }
+  return lines.join('\n')
+}
+
+export function prettyPrintString(value: CljValue, maxWidth = 80): string {
+  return pp(value, 0, maxWidth)
+}

package/src/core/reader.ts

@@ -1,17 +1,11 @@
 import { ReaderError } from './errors'
-import {
-  cljBoolean,
-  cljList,
-  cljNil,
-  cljRegex,
-  cljSymbol,
-  cljVector,
-} from './factories'
+import { v } from './factories'
+import { is } from './assertions'
 import { makeTokenScanner, type TokenScanner } from './scanners'
 import { getTokenValue } from './tokenizer'
 import { valueKeywords, tokenKeywords, type Token } from './types'
 import type { CljValue, TokenKinds } from './types'
-import { setPos } from './positions'
+import { getPos, setPos } from './positions'
 
 function readAtom(ctx: ReaderCtx): CljValue {
   const scanner = ctx.scanner
@@ -84,7 +78,7 @@ const readQuote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [cljSymbol('quote'), value] }
+  return { kind: valueKeywords.list, value: [v.symbol('quote'), value] }
 }
 
 const readQuasiquote = (ctx: ReaderCtx) => {
@@ -101,7 +95,7 @@ const readQuasiquote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [cljSymbol('quasiquote'), value] }
+  return { kind: valueKeywords.list, value: [v.symbol('quasiquote'), value] }
 }
 
 const readUnquote = (ctx: ReaderCtx) => {
@@ -118,7 +112,53 @@ const readUnquote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [cljSymbol('unquote'), value] }
+  return { kind: valueKeywords.list, value: [v.symbol('unquote'), value] }
+}
+
+const readMeta = (ctx: ReaderCtx): CljValue => {
+  const scanner = ctx.scanner
+  const token = scanner.peek()
+  if (!token) {
+    throw new ReaderError(
+      'Unexpected end of input while parsing metadata',
+      scanner.position()
+    )
+  }
+  scanner.advance() // consume Meta token
+
+  const metaForm = readForm(ctx)
+  const target = readForm(ctx)
+
+  // Convert metaForm to a CljMap
+  let metaEntries: [CljValue, CljValue][]
+  if (metaForm.kind === 'keyword') {
+    metaEntries = [[metaForm, v.boolean(true)]]
+  } else if (metaForm.kind === 'map') {
+    metaEntries = metaForm.entries
+  } else if (metaForm.kind === 'symbol') {
+    metaEntries = [[v.keyword(':tag'), metaForm]]
+  } else {
+    throw new ReaderError('Metadata must be a keyword, map, or symbol', token)
+  }
+
+  // Attach metadata to IMeta targets: symbols, lists, vectors, maps.
+  if (
+    target.kind === 'symbol' ||
+    target.kind === 'list' ||
+    target.kind === 'vector' ||
+    target.kind === 'map'
+  ) {
+    const existingEntries = target.meta ? target.meta.entries : []
+    const result = {
+      ...target,
+      meta: v.map([...existingEntries, ...metaEntries]),
+    }
+    // Spread drops non-enumerable properties like _pos — re-attach it.
+    const pos = getPos(target)
+    if (pos) setPos(result, pos)
+    return result
+  }
+  return target
 }
 
 const readVarQuote = (ctx: ReaderCtx) => {
@@ -126,13 +166,13 @@ const readVarQuote = (ctx: ReaderCtx) => {
   const token = scanner.peek()
   if (!token) {
     throw new ReaderError(
-      "Unexpected end of input while parsing var quote",
+      'Unexpected end of input while parsing var quote',
       scanner.position()
     )
   }
   scanner.advance() // consume VarQuote token
   const value = readForm(ctx)
-  return cljList([cljSymbol('var'), value])
+  return v.list([v.symbol('var'), value])
 }
 
 const readDeref = (ctx: ReaderCtx) => {
@@ -149,7 +189,7 @@ const readDeref = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [cljSymbol('deref'), value] }
+  return { kind: valueKeywords.list, value: [v.symbol('deref'), value] }
 }
 
 const readUnquoteSplicing = (ctx: ReaderCtx) => {
@@ -168,7 +208,7 @@ const readUnquoteSplicing = (ctx: ReaderCtx) => {
   }
   return {
     kind: valueKeywords.list,
-    value: [cljSymbol('unquote-splicing'), value],
+    value: [v.symbol('unquote-splicing'), value],
   }
 }
 
@@ -235,6 +275,60 @@ const readList = collectionReader('list', tokenKeywords.RParen)
 
 const readVector = collectionReader('vector', tokenKeywords.RBracket)
 
+const readSet = (ctx: ReaderCtx) => {
+  const scanner = ctx.scanner
+  const startToken = scanner.peek()
+  if (!startToken) {
+    throw new ReaderError(
+      'Unexpected end of input while parsing set',
+      scanner.position()
+    )
+  }
+  scanner.advance() // consume the SetStart token
+
+  const values: CljValue[] = []
+  let pairMatched = false
+  let closingEnd: number | undefined
+  while (!scanner.isAtEnd()) {
+    const token = scanner.peek()
+    if (!token) break
+    if (isClosingToken(token) && token.kind !== tokenKeywords.RBrace) {
+      throw new ReaderError(
+        `Expected '}' to close set started at line ${startToken.start.line} column ${startToken.start.col}, but got '${getTokenValue(token)}' at line ${token.start.line} column ${token.start.col}`,
+        token,
+        { start: token.start.offset, end: token.end.offset }
+      )
+    }
+    if (token.kind === tokenKeywords.RBrace) {
+      closingEnd = token.end.offset
+      scanner.advance() // consume the closing brace
+      pairMatched = true
+      break
+    }
+    values.push(readForm(ctx))
+  }
+  if (!pairMatched) {
+    throw new ReaderError(
+      `Unmatched set started at line ${startToken.start.line} column ${startToken.start.col}`,
+      scanner.peek()
+    )
+  }
+
+  // Deduplicate using isEqual
+  const deduped: CljValue[] = []
+  for (const v of values) {
+    if (!deduped.some((existing) => is.equal(existing, v))) {
+      deduped.push(v)
+    }
+  }
+
+  const result = v.set(deduped)
+  if (closingEnd !== undefined) {
+    setPos(result, { start: startToken.start.offset, end: closingEnd })
+  }
+  return result
+}
+
 const readSymbol = (scanner: TokenScanner) => {
   const token = scanner.peek()
   if (!token) {
@@ -251,13 +345,13 @@ const readSymbol = (scanner: TokenScanner) => {
   switch (token.value) {
     case 'true':
     case 'false':
-      val = cljBoolean(token.value === 'true')
+      val = v.boolean(token.value === 'true')
       break
     case 'nil':
-      val = cljNil()
+      val = v.nil()
       break
     default:
-      val = cljSymbol(token.value)
+      val = v.symbol(token.value)
   }
   setPos(val, { start: token.start.offset, end: token.end.offset })
   return val
@@ -371,9 +465,9 @@ function substituteAnonFnParams(form: CljValue): CljValue {
   switch (form.kind) {
     case 'symbol': {
       const name = form.name
-      if (name === '%' || name === '%1') return cljSymbol('p1')
-      if (/^%[2-9]$/.test(name)) return cljSymbol(`p${name[1]}`)
-      if (name === '%&') return cljSymbol('rest')
+      if (name === '%' || name === '%1') return v.symbol('p1')
+      if (/^%[2-9]$/.test(name)) return v.symbol(`p${name[1]}`)
+      if (name === '%&') return v.symbol('rest')
       return form
     }
     case 'list':
@@ -449,18 +543,18 @@ const readAnonFn = (ctx: ReaderCtx) => {
 
   const paramSymbols: CljValue[] = []
   for (let i = 1; i <= maxIndex; i++) {
-    paramSymbols.push(cljSymbol(`p${i}`))
+    paramSymbols.push(v.symbol(`p${i}`))
   }
   if (hasRest) {
-    paramSymbols.push(cljSymbol('&'))
-    paramSymbols.push(cljSymbol('rest'))
+    paramSymbols.push(v.symbol('&'))
+    paramSymbols.push(v.symbol('rest'))
   }
 
   const substitutedBody = substituteAnonFnParams(bodyList)
 
-  const result = cljList([
-    cljSymbol('fn'),
-    cljVector(paramSymbols),
+  const result = v.list([
+    v.symbol('fn'),
+    v.vector(paramSymbols),
     substitutedBody,
   ])
   if (closingEnd !== undefined) {
@@ -500,7 +594,7 @@ const readRegex = (ctx: ReaderCtx): CljValue => {
   }
   scanner.advance()
   const { pattern, flags } = extractInlineFlags(token.value)
-  const val = cljRegex(pattern, flags)
+  const val = v.regex(pattern, flags)
   setPos(val, { start: token.start.offset, end: token.end.offset })
   return val
 }
@@ -533,10 +627,14 @@ function readForm(ctx: ReaderCtx): CljValue {
       return readUnquoteSplicing(ctx)
     case tokenKeywords.AnonFnStart:
       return readAnonFn(ctx)
+    case tokenKeywords.SetStart:
+      return readSet(ctx)
     case tokenKeywords.Deref:
       return readDeref(ctx)
     case tokenKeywords.VarQuote:
       return readVarQuote(ctx)
+    case tokenKeywords.Meta:
+      return readMeta(ctx)
     case tokenKeywords.Regex:
       return readRegex(ctx)
     default: