conjure-js 0.0.11 → 0.0.13

package/src/core/stdlib/vectors.ts

@@ -0,0 +1,122 @@
+// Vector-specific operations: vector, vec, subvec, peek, pop
+//
+// These functions are exclusively concerned with vectors (or lists treated as
+// a stack for peek/pop). Pure vector construction and stack operations.
+
+import { is } from '../assertions'
+import { EvaluationError } from '../errors'
+import { v } from '../factories'
+import { printString } from '../printer'
+import { toSeq } from '../transformations'
+import { type CljValue } from '../types'
+
+export const vectorFunctions: Record<string, CljValue> = {
+  vector: v
+    .nativeFn('vector', function vectorImpl(...args: CljValue[]) {
+      if (args.length === 0) {
+        return v.vector([])
+      }
+      return v.vector(args)
+    })
+    .doc('Returns a new vector containing the given values.', [['&', 'args']]),
+
+  vec: v
+    .nativeFn('vec', function vecImpl(coll: CljValue) {
+      if (coll === undefined || coll.kind === 'nil') return v.vector([])
+      if (is.vector(coll)) return coll
+      if (!is.seqable(coll)) {
+        throw EvaluationError.atArg(
+          `vec expects a collection or string, got ${printString(coll)}`,
+          { coll },
+          0
+        )
+      }
+      return v.vector(toSeq(coll))
+    })
+    .doc('Creates a new vector containing the contents of coll.', [['coll']]),
+
+  subvec: v
+    .nativeFn(
+      'subvec',
+      function subvecImpl(vector: CljValue, start: CljValue, end?: CljValue) {
+        if (vector === undefined || !is.vector(vector)) {
+          throw EvaluationError.atArg(
+            `subvec expects a vector, got ${printString(vector)}`,
+            { v: vector },
+            0
+          )
+        }
+        if (start === undefined || start.kind !== 'number') {
+          throw EvaluationError.atArg(
+            `subvec expects a number start index`,
+            { start },
+            1
+          )
+        }
+        const s = start.value
+        const e =
+          end !== undefined && end.kind === 'number'
+            ? end.value
+            : vector.value.length
+        if (s < 0 || e > vector.value.length || s > e) {
+          throw new EvaluationError(
+            `subvec index out of bounds: start=${s}, end=${e}, length=${vector.value.length}`,
+            { v: vector, start, end }
+          )
+        }
+        return v.vector(vector.value.slice(s, e))
+      }
+    )
+    .doc(
+      'Returns a persistent vector of the items in vector from start (inclusive) to end (exclusive).',
+      [
+        ['v', 'start'],
+        ['v', 'start', 'end'],
+      ]
+    ),
+
+  peek: v
+    .nativeFn('peek', function peekImpl(coll: CljValue) {
+      if (coll === undefined || coll.kind === 'nil') return v.nil()
+      if (is.vector(coll)) {
+        return coll.value.length === 0
+          ? v.nil()
+          : coll.value[coll.value.length - 1]
+      }
+      if (is.list(coll)) {
+        return coll.value.length === 0 ? v.nil() : coll.value[0]
+      }
+      throw EvaluationError.atArg(
+        `peek expects a list or vector, got ${printString(coll)}`,
+        { coll },
+        0
+      )
+    })
+    .doc('For a list, same as first. For a vector, same as last.', [['coll']]),
+
+  pop: v
+    .nativeFn('pop', function popImpl(coll: CljValue) {
+      if (coll === undefined || coll.kind === 'nil') {
+        throw EvaluationError.atArg("Can't pop empty list", { coll }, 0)
+      }
+      if (is.vector(coll)) {
+        if (coll.value.length === 0)
+          throw new EvaluationError("Can't pop empty vector", { coll })
+        return v.vector(coll.value.slice(0, -1))
+      }
+      if (is.list(coll)) {
+        if (coll.value.length === 0)
+          throw new EvaluationError("Can't pop empty list", { coll })
+        return v.list(coll.value.slice(1))
+      }
+      throw EvaluationError.atArg(
+        `pop expects a list or vector, got ${printString(coll)}`,
+        { coll },
+        0
+      )
+    })
+    .doc(
+      'For a list, returns a new list without the first item. For a vector, returns a new vector without the last item.',
+      [['coll']]
+    ),
+}

package/src/core/tokenizer.ts

@@ -33,6 +33,7 @@ const isNumber = (char: string) => {
 const isDot = (char: string) => char === '.'
 const isKeywordStart = (char: string) => char === ':'
 const isHash = (char: string) => char === '#'
+const isCaret = (char: string) => char === '^'
 
 const isDelimiter = (char: string) =>
   isLParen(char) ||
@@ -43,7 +44,8 @@ const isDelimiter = (char: string) =>
   isRBrace(char) ||
   isBacktick(char) ||
   isSingleQuote(char) ||
-  isAt(char)
+  isAt(char) ||
+  isCaret(char)
 
 const parseWhitespace = (ctx: TokenizationContext): Token => {
   const scanner = ctx.scanner
@@ -217,6 +219,13 @@ const parseDerefToken = (ctx: TokenizationContext): Token => {
   return { kind: 'Deref', start, end: scanner.position() }
 }
 
+const parseMetaToken = (ctx: TokenizationContext): Token => {
+  const scanner = ctx.scanner
+  const start = scanner.position()
+  scanner.advance() // consume '^'
+  return { kind: 'Meta', start, end: scanner.position() }
+}
+
 const parseRegexLiteral = (ctx: TokenizationContext, start: ReturnType<typeof ctx.scanner.position>): Token => {
   const scanner = ctx.scanner
   scanner.advance() // consume opening '"'
@@ -285,8 +294,8 @@ function parseDispatch(ctx: TokenizationContext): Token {
     return { kind: tokenKeywords.VarQuote, start, end: scanner.position() }
   }
   if (next === '{') {
-    // TODO: set literals — #{1 2 3}
-    throw new TokenizerError('Set literals are not yet supported', start)
+    scanner.advance() // consume '{'
+    return { kind: tokenKeywords.SetStart, start, end: scanner.position() }
   }
   throw new TokenizerError(
     `Unknown dispatch character: #${next ?? 'EOF'}`,
@@ -364,6 +373,7 @@ const tokenParseEntries: TokenParseEntry[] = [
   ],
   [isTilde, parseTilde],
   [isAt, parseDerefToken],
+  [isCaret, parseMetaToken],
   [isHash, parseDispatch],
 ]
 

package/src/core/transformations.ts

@@ -1,8 +1,8 @@
-import { isList, isMap, isVector } from './assertions'
+import { isCons, isLazySeq, isList, isMap, isNil, isSet, isVector } from './assertions'
 import { EvaluationError } from './errors'
 import { cljString, cljVector } from './factories'
-import { printString } from './printer'
-import { type CljValue, valueKeywords } from './types'
+import { printString, getPrintContext } from './printer'
+import { type CljCons, type CljDelay, type CljLazySeq, type CljValue, valueKeywords } from './types'
 
 export function valueToString(value: CljValue): string {
   switch (value.kind) {
@@ -16,12 +16,30 @@ export function valueToString(value: CljValue): string {
       return value.name
     case valueKeywords.symbol:
       return value.name
-    case valueKeywords.list:
-      return `(${value.value.map(valueToString).join(' ')})`
-    case valueKeywords.vector:
-      return `[${value.value.map(valueToString).join(' ')}]`
-    case valueKeywords.map:
-      return `{${value.entries.map(([key, value]) => `${valueToString(key)} ${valueToString(value)}`).join(' ')}}`
+    case valueKeywords.list: {
+      const { printLength } = getPrintContext()
+      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `(${items.map(valueToString).join(' ')}${suffix})`
+    }
+    case valueKeywords.vector: {
+      const { printLength } = getPrintContext()
+      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `[${items.map(valueToString).join(' ')}${suffix}]`
+    }
+    case valueKeywords.map: {
+      const { printLength } = getPrintContext()
+      const entries = printLength !== null ? value.entries.slice(0, printLength) : value.entries
+      const suffix = printLength !== null && value.entries.length > printLength ? ' ...' : ''
+      return `{${entries.map(([key, v]) => `${valueToString(key)} ${valueToString(v)}`).join(' ')}${suffix}}`
+    }
+    case valueKeywords.set: {
+      const { printLength } = getPrintContext()
+      const items = printLength !== null ? value.values.slice(0, printLength) : value.values
+      const suffix = printLength !== null && value.values.length > printLength ? ' ...' : ''
+      return `#{${items.map(valueToString).join(' ')}${suffix}}`
+    }
     case valueKeywords.function: {
       if (value.arities.length === 1) {
         const a = value.arities[0]
@@ -48,6 +66,26 @@ export function valueToString(value: CljValue): string {
       const prefix = value.flags ? `(?${value.flags})` : ''
       return `${prefix}${value.pattern}`
     }
+    case valueKeywords.delay:
+      return value.realized ? `#<Delay @${valueToString(value.value!)}>` : '#<Delay pending>'
+    case valueKeywords.lazySeq: {
+      const realized = realizeLazySeq(value)
+      if (isNil(realized)) return '()'
+      return valueToString(realized)
+    }
+    case valueKeywords.cons: {
+      const items = consToArray(value)
+      const { printLength } = getPrintContext()
+      const visible = printLength !== null ? items.slice(0, printLength) : items
+      const suffix = printLength !== null && items.length > printLength ? ' ...' : ''
+      return `(${visible.map(valueToString).join(' ')}${suffix})`
+    }
+    case valueKeywords.namespace:
+      return `#namespace[${value.name}]`
+    case 'pending':
+      if (value.resolved && value.resolvedValue !== undefined)
+        return `#<Pending @${valueToString(value.resolvedValue)}>`
+      return '#<Pending>'
     default:
       throw new EvaluationError(`unhandled value type: ${value.kind}`, {
         value,
@@ -55,6 +93,35 @@ export function valueToString(value: CljValue): string {
   }
 }
 
+/** Realize a delay: evaluate thunk once, cache result. */
+export function realizeDelay(d: CljDelay): CljValue {
+  if (d.realized) return d.value!
+  d.value = d.thunk()
+  d.realized = true
+  return d.value!
+}
+
+/** Realize a lazy-seq: evaluate thunk once, cache result. Trampolines through chained lazy-seqs. */
+export function realizeLazySeq(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
+}
+
 export const toSeq = (collection: CljValue): CljValue[] => {
   if (isList(collection)) {
     return collection.value
@@ -65,11 +132,52 @@ export const toSeq = (collection: CljValue): CljValue[] => {
   if (isMap(collection)) {
     return collection.entries.map(([k, v]) => cljVector([k, v]))
   }
+  if (isSet(collection)) {
+    return collection.values
+  }
   if (collection.kind === 'string') {
     return [...collection.value].map(cljString)
   }
+  if (isLazySeq(collection)) {
+    const realized = realizeLazySeq(collection)
+    if (isNil(realized)) return []
+    return toSeq(realized)
+  }
+  if (isCons(collection)) {
+    return consToArray(collection)
+  }
   throw new EvaluationError(
     `toSeq expects a collection or string, got ${printString(collection)}`,
     { collection }
   )
 }
+
+/** Walk a cons/lazy-seq chain into a flat array (trampoline, no recursion). */
+export function consToArray(c: CljCons): CljValue[] {
+  const result: CljValue[] = [c.head]
+  let tail: CljValue = c.tail
+  while (true) {
+    if (isNil(tail)) break
+    if (isCons(tail)) {
+      result.push(tail.head)
+      tail = tail.tail
+      continue
+    }
+    if (isLazySeq(tail)) {
+      tail = realizeLazySeq(tail)
+      continue
+    }
+    if (isList(tail)) {
+      result.push(...tail.value)
+      break
+    }
+    if (isVector(tail)) {
+      result.push(...tail.value)
+      break
+    }
+    // Other seqable types — fall through to toSeq
+    result.push(...toSeq(tail))
+    break
+  }
+  return result
+}

package/src/core/types.ts

@@ -17,6 +17,12 @@ export const valueKeywords = {
   volatile: 'volatile',
   regex: 'regex',
   var: 'var',
+  set: 'set',
+  delay: 'delay',
+  lazySeq: 'lazy-seq',
+  cons: 'cons',
+  namespace: 'namespace',
+  jsValue: 'js-value',
 } as const
 export type ValueKeywords = (typeof valueKeywords)[keyof typeof valueKeywords]
 
@@ -25,11 +31,12 @@ export type CljString = { kind: 'string'; value: string }
 export type CljBoolean = { kind: 'boolean'; value: boolean }
 export type CljKeyword = { kind: 'keyword'; name: string }
 export type CljNil = { kind: 'nil'; value: null }
-export type CljSymbol = { kind: 'symbol'; name: string }
-export type CljList = { kind: 'list'; value: CljValue[] }
-export type CljVector = { kind: 'vector'; value: CljValue[] }
-export type CljMap = { kind: 'map'; entries: [CljValue, CljValue][] }
+export type CljSymbol = { kind: 'symbol'; name: string; meta?: CljMap }
+export type CljList = { kind: 'list'; value: CljValue[]; meta?: CljMap }
+export type CljVector = { kind: 'vector'; value: CljValue[]; meta?: CljMap }
+export type CljMap = { kind: 'map'; entries: [CljValue, CljValue][]; meta?: CljMap }
 export type CljNamespace = {
+  kind: 'namespace'
   name: string
   vars: Map<string, CljVar>            // user defs from (def ...)
   aliases: Map<string, CljNamespace>   // :as namespace aliases
@@ -40,7 +47,6 @@ export type Env = {
   bindings: Map<string, CljValue>      // native fns, macros, multimethods, local values
   outer: Env | null
   ns?: CljNamespace                    // set on namespace-root envs only
-  resolveNs?: (name: string) => Env | null // set on coreEnv only
 }
 
 export type DestructurePattern = CljSymbol | CljVector | CljMap
@@ -55,6 +61,7 @@ export type CljFunction = {
   kind: 'function'
   arities: Arity[]
   env: Env
+  name?: string   // set for named fn: (fn my-name [x] x)
   meta?: CljMap
 }
 
@@ -62,18 +69,50 @@ export type CljMacro = {
   kind: 'macro'
   arities: Arity[]
   env: Env
+  name?: string   // set for named defmacro
 }
 
-export type CljAtom = { kind: 'atom'; value: CljValue }
+export type CljAtom = {
+  kind: 'atom'
+  value: CljValue
+  meta?: CljMap
+  watches?: Map<string, { key: CljValue; fn: CljValue; ctx: EvaluationContext; callEnv: Env }>
+  validator?: CljValue
+}
 export type CljReduced = { kind: 'reduced'; value: CljValue }
 export type CljVolatile = { kind: 'volatile'; value: CljValue }
 export type CljRegex = { kind: 'regex'; pattern: string; flags: string }
 
+export type CljSet = { kind: 'set'; values: CljValue[] }
+
+export type CljDelay = {
+  kind: 'delay'
+  thunk: () => CljValue
+  realized: boolean
+  value?: CljValue
+}
+
+export type CljLazySeq = {
+  kind: 'lazy-seq'
+  thunk: (() => CljValue) | null
+  realized: boolean
+  value?: CljValue  // nil, list, cons, or another lazy-seq after realization
+}
+
+export type CljCons = {
+  kind: 'cons'
+  head: CljValue
+  tail: CljValue  // can be list, vector, lazy-seq, cons, or nil
+  meta?: CljMap
+}
+
 export type CljVar = {
   kind: 'var'
   ns: string
   name: string
   value: CljValue
+  dynamic?: boolean          // set when def is annotated with ^:dynamic
+  bindingStack?: CljValue[]  // active dynamic bindings (push/pop by `binding`)
   meta?: CljMap
 }
 
@@ -85,6 +124,17 @@ export type CljMultiMethod = {
   defaultMethod?: CljFunction | CljNativeFunction
 }
 
+/**
+ * IO channels for a session. stdout is the primary output channel (println,
+ * print, pr, prn, pprint, newline). stderr is available for error output.
+ * Both are set by the session on context creation and read at call time by
+ * IO native functions — no closure capture, no reinstallation on restore.
+ */
+export type IOContext = {
+  stdout: (text: string) => void
+  stderr: (text: string) => void
+}
+
 export type EvaluationContext = {
   evaluate: (expr: CljValue, env: Env) => CljValue
   evaluateForms: (forms: CljValue[], env: Env) => CljValue
@@ -97,6 +147,39 @@ export type EvaluationContext = {
   applyCallable: (fn: CljValue, args: CljValue[], callEnv: Env) => CljValue
   applyMacro: (macro: CljMacro, rawArgs: CljValue[]) => CljValue
   expandAll: (form: CljValue, env: Env) => CljValue
+  /**
+   * Resolves a namespace name (or alias) to its CljNamespace record.
+   * Wired by the session/runtime after context creation; defaults to no-op null.
+   */
+  resolveNs: (name: string) => CljNamespace | null
+  /**
+   * IO channels — set by the session in buildSessionFacade.
+   * IO native functions (println, print, pr, prn, pprint, newline) read
+   * ctx.io.stdout at call time instead of closing over an emit callback.
+   * This means snapshot clones automatically use the correct output without
+   * any reinstallation of IO vars.
+   */
+  io: IOContext
+  /**
+   * Mutable per-call fields set by session.evaluate / loadFile before
+   * executing forms. Used by evaluateDef to stamp :line/:column/:file onto
+   * vars. This codebase is synchronous, so mutation is safe.
+   */
+  currentSource?: string
+  currentFile?: string
+  currentLineOffset?: number
+  currentColOffset?: number
+  /**
+   * Optional module loader for string `:require` specs.
+   * Called by processNsRequiresAsync when it encounters ["specifier" :as Alias].
+   * Wired from SessionOptions.importModule in buildSessionFacade.
+   */
+  importModule?: (specifier: string) => unknown | Promise<unknown>
+  /**
+   * Switches the session's current namespace. Wired by buildSessionFacade.
+   * Called by `in-ns` at runtime. Without this hook, `in-ns` is a no-op.
+   */
+  setCurrentNs?: (name: string) => void
 }
 
 export type CljNativeFunction = {
@@ -112,6 +195,18 @@ export type CljNativeFunction = {
   meta?: CljMap
 }
 
+export type CljJsValue = { kind: 'js-value'; value: unknown }
+
+// --- ASYNC (experimental, see evaluator/async-evaluator.ts) ---
+export type CljPending = {
+  kind: 'pending'
+  promise: Promise<CljValue>
+  /** Set to true once the promise settles (fulfilled only). */
+  resolved?: boolean
+  resolvedValue?: CljValue
+}
+// --- END ASYNC ---
+
 export type CljValue =
   | CljNumber
   | CljString
@@ -131,6 +226,13 @@ export type CljValue =
   | CljVolatile
   | CljRegex
   | CljVar
+  | CljSet
+  | CljDelay
+  | CljLazySeq
+  | CljCons
+  | CljNamespace
+  | CljPending
+  | CljJsValue
 
 /** Tokens */
 export const tokenKeywords = {
@@ -154,6 +256,8 @@ export const tokenKeywords = {
   Deref: 'Deref',
   Regex: 'Regex',
   VarQuote: 'VarQuote',
+  Meta: 'Meta',
+  SetStart: 'SetStart',
 } as const
 export const tokenSymbols = {
   Quote: 'quote',
@@ -254,6 +358,12 @@ export type TokenRegex = {
 export type TokenVarQuote = {
   kind: 'VarQuote'
 }
+export type TokenMeta = {
+  kind: 'Meta'
+}
+export type TokenSetStart = {
+  kind: 'SetStart'
+}
 export type Token = (
   | TokenLParen
   | TokenRParen
@@ -275,4 +385,6 @@ export type Token = (
   | TokenDeref
   | TokenRegex
   | TokenVarQuote
+  | TokenMeta
+  | TokenSetStart
 ) & { start: Cursor; end: Cursor }

package/src/host/node-host-module.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import {
+  cljNativeFunction,
+  cljNil,
+  cljString,
+  valueToString,
+  type Session,
+  type CljValue,
+} from '../core'
+import type { RuntimeModule } from '../core/module'
+import { inferSourceRoot } from '../bin/nrepl-utils'
+
+/**
+ * Returns a RuntimeModule that installs Node.js host functions into clojure.core.
+ * Closes over the session for functions (like `load`) that need to drive evaluation.
+ */
+export function makeNodeHostModule(session: Session): RuntimeModule {
+  return {
+    id: 'conjure/host-node',
+    dependsOn: ['clojure.core'],
+    declareNs: [
+      {
+        name: 'clojure.core',
+        vars(_ctx) {
+          return new Map([
+            [
+              'slurp',
+              {
+                value: cljNativeFunction('slurp', (pathVal: CljValue) => {
+                  const filePath = resolve(valueToString(pathVal))
+                  if (!existsSync(filePath)) {
+                    throw new Error(`slurp: file not found: ${filePath}`)
+                  }
+                  return cljString(readFileSync(filePath, 'utf8'))
+                }),
+              },
+            ],
+            [
+              'spit',
+              {
+                value: cljNativeFunction(
+                  'spit',
+                  (pathVal: CljValue, content: CljValue) => {
+                    const filePath = resolve(valueToString(pathVal))
+                    writeFileSync(filePath, valueToString(content), 'utf8')
+                    return cljNil()
+                  }
+                ),
+              },
+            ],
+            [
+              'load',
+              {
+                value: cljNativeFunction('load', (pathVal: CljValue) => {
+                  const filePath = resolve(valueToString(pathVal))
+                  if (!existsSync(filePath)) {
+                    throw new Error(`load: file not found: ${filePath}`)
+                  }
+                  const source = readFileSync(filePath, 'utf8')
+                  const inferred = inferSourceRoot(filePath, source)
+                  if (inferred) session.addSourceRoot(inferred)
+                  const loadedNs = session.loadFile(source)
+                  session.setNs(loadedNs)
+                  return cljNil()
+                }),
+              },
+            ],
+          ])
+        },
+      },
+    ],
+  }
+}