conjure-js 0.0.1

package/src/core/core-env.ts

@@ -0,0 +1,58 @@
+import { define, makeEnv } from './env'
+import { cljNativeFunction, cljNil } from './factories'
+import { arithmeticFunctions } from './stdlib/arithmetic'
+import { atomFunctions } from './stdlib/atoms'
+import { collectionFunctions } from './stdlib/collections'
+import { errorFunctions } from './stdlib/errors'
+import { hofFunctions } from './stdlib/hof'
+import { metaFunctions } from './stdlib/meta'
+import { predicateFunctions } from './stdlib/predicates'
+import { regexFunctions } from './stdlib/regex'
+import { stringFunctions } from './stdlib/strings'
+import { transducerFunctions } from './stdlib/transducers'
+import { utilFunctions } from './stdlib/utils'
+import { valueToString } from './transformations'
+import { type CljValue, type Env } from './types'
+
+const nativeFunctions = {
+  ...arithmeticFunctions,
+  ...atomFunctions,
+  ...collectionFunctions,
+  ...errorFunctions,
+  ...predicateFunctions,
+  ...hofFunctions,
+  ...metaFunctions,
+  ...transducerFunctions,
+  ...regexFunctions,
+  ...stringFunctions,
+  ...utilFunctions,
+}
+
+export function loadCoreFunctions(env: Env, output?: (text: string) => void) {
+  for (const [key, value] of Object.entries(nativeFunctions)) {
+    define(key, value, env)
+  }
+  const emit = output ?? ((text: string) => console.log(text))
+  define(
+    'println',
+    cljNativeFunction('println', (...args: CljValue[]) => {
+      emit(args.map(valueToString).join(' '))
+      return cljNil()
+    }),
+    env
+  )
+  define(
+    'print',
+    cljNativeFunction('print', (...args: CljValue[]) => {
+      emit(args.map(valueToString).join(' '))
+      return cljNil()
+    }),
+    env
+  )
+}
+
+export function makeCoreEnv(output?: (text: string) => void): Env {
+  const env = makeEnv()
+  loadCoreFunctions(env, output)
+  return env
+}

package/src/core/env.ts

@@ -0,0 +1,78 @@
+import { EvaluationError } from './errors'
+import type { CljValue, Env } from './types'
+
+class EnvError extends Error {
+  context: any
+  constructor(message: string, context: any) {
+    super(message)
+    this.context = context
+    this.name = 'EnvError'
+  }
+}
+
+export function makeEnv(outer?: Env): Env {
+  return {
+    bindings: new Map(),
+    outer: outer ?? null,
+  }
+}
+
+export function lookup(name: string, env: Env): CljValue {
+  let current = env as Env | null
+  while (current) {
+    if (current.bindings.has(name)) {
+      return current.bindings.get(name)!
+    }
+    current = current.outer
+  }
+  throw new EvaluationError(`Symbol ${name} not found`, { name })
+}
+
+export function tryLookup(name: string, env: Env): CljValue | undefined {
+  let current = env as Env | null
+  while (current) {
+    if (current.bindings.has(name)) {
+      return current.bindings.get(name)!
+    }
+    current = current.outer
+  }
+  return undefined
+}
+
+export function define(name: string, value: CljValue, env: Env) {
+  env.bindings.set(name, value)
+}
+
+export function extend(params: string[], args: CljValue[], outer: Env): Env {
+  if (params.length !== args.length) {
+    throw new EnvError('Number of parameters and arguments must match', {
+      params,
+      args,
+      outer,
+    })
+  }
+  const env = makeEnv(outer)
+  for (let i = 0; i < params.length; i++) {
+    define(params[i], args[i], env)
+  }
+  return env
+}
+
+export function getRootEnv(env: Env): Env {
+  let current = env as Env | null
+  while (current?.outer) {
+    current = current.outer
+  }
+  return current!
+}
+
+export function getNamespaceEnv(env: Env): Env {
+  let current: Env | null = env
+  while (current) {
+    if (current.namespace) return current
+    current = current.outer
+  }
+  // fallback for un-namespaced envs for backwards compact
+  // eventually we'll remove this and require all envs to be namespaced
+  return getRootEnv(env)
+}

package/src/core/errors.ts

@@ -0,0 +1,39 @@
+import type { CljValue, Pos } from './types'
+
+export class TokenizerError extends Error {
+  context: unknown
+  constructor(message: string, context: unknown) {
+    super(message)
+    this.name = 'TokenizerError'
+    this.context = context
+  }
+}
+
+export class ReaderError extends Error {
+  context: unknown
+  pos?: Pos
+  constructor(message: string, context: unknown, pos?: Pos) {
+    super(message)
+    this.name = 'ReaderError'
+    this.context = context
+    this.pos = pos
+  }
+}
+
+export class EvaluationError extends Error {
+  context: unknown
+  pos?: Pos
+  constructor(message: string, context: unknown, pos?: Pos) {
+    super(message)
+    this.name = 'EvaluationError'
+    this.context = context
+    this.pos = pos
+  }
+}
+
+export class CljThrownSignal {
+  value: CljValue
+  constructor(value: CljValue) {
+    this.value = value
+  }
+}

package/src/core/evaluator/apply.ts

@@ -0,0 +1,114 @@
+import { isAFunction, isEqual, isKeyword, isMap } from '../assertions'
+import { EvaluationError } from '../errors'
+import { cljNil } from '../factories'
+import { printString } from '../printer'
+import type {
+  CljFunction,
+  CljMacro,
+  CljNativeFunction,
+  CljValue,
+  Env,
+  EvaluationContext,
+} from '../types'
+import { bindParams, RecurSignal, resolveArity } from './arity'
+
+export function applyFunctionWithContext(
+  fn: CljFunction | CljNativeFunction,
+  args: CljValue[],
+  ctx: EvaluationContext,
+  callEnv: Env
+): CljValue {
+  if (fn.kind === 'native-function') {
+    // New path, native fns receive evaluation context as first argument
+    if (fn.fnWithContext) {
+      return fn.fnWithContext(ctx, callEnv, ...args)
+    }
+    return fn.fn(...args)
+  }
+  if (fn.kind === 'function') {
+    const arity = resolveArity(fn.arities, args.length)
+    let currentArgs = args
+    while (true) {
+      const localEnv = bindParams(
+        arity.params,
+        arity.restParam,
+        currentArgs,
+        fn.env,
+        ctx,
+        callEnv
+      )
+      try {
+        return ctx.evaluateForms(arity.body, localEnv)
+      } catch (e) {
+        if (e instanceof RecurSignal) {
+          currentArgs = e.args
+          continue
+        }
+        throw e
+      }
+    }
+  }
+
+  throw new EvaluationError(
+    `${(fn as CljValue).kind} is not a callable function`,
+    {
+      fn,
+      args,
+    }
+  )
+}
+
+/**
+ * Invokes any IFn value — functions, native functions, keywords, and maps.
+ * Used by comp, partial, and any other HOF that needs to call an arbitrary
+ * callable without going through the full list-evaluation dispatch.
+ */
+export function applyCallableWithContext(
+  fn: CljValue,
+  args: CljValue[],
+  ctx: EvaluationContext,
+  callEnv: Env
+): CljValue {
+  if (isAFunction(fn)) {
+    return applyFunctionWithContext(fn, args, ctx, callEnv)
+  }
+  if (isKeyword(fn)) {
+    const target = args[0]
+    const defaultVal = args.length > 1 ? args[1] : cljNil()
+    if (isMap(target)) {
+      const entry = target.entries.find(([k]) => isEqual(k, fn))
+      return entry ? entry[1] : defaultVal
+    }
+    return defaultVal
+  }
+  if (isMap(fn)) {
+    if (args.length === 0) {
+      throw new EvaluationError('Map used as function requires at least one argument', { fn, args })
+    }
+    const key = args[0]
+    const defaultVal = args.length > 1 ? args[1] : cljNil()
+    const entry = fn.entries.find(([k]) => isEqual(k, key))
+    return entry ? entry[1] : defaultVal
+  }
+  throw new EvaluationError(`${printString(fn)} is not a callable value`, {
+    fn,
+    args,
+  })
+}
+
+export function applyMacroWithContext(
+  macro: CljMacro,
+  rawArgs: CljValue[],
+  ctx: EvaluationContext
+): CljValue {
+  const arity = resolveArity(macro.arities, rawArgs.length)
+  const localEnv = bindParams(
+    arity.params,
+    arity.restParam,
+    rawArgs,
+    macro.env,
+    ctx,
+    macro.env
+  )
+  return ctx.evaluateForms(arity.body, localEnv)
+}

package/src/core/evaluator/arity.ts

@@ -0,0 +1,174 @@
+import { isList, isMap, isSymbol, isVector } from '../assertions'
+import { extend } from '../env'
+import { EvaluationError } from '../errors'
+import { cljList, cljNil } from '../factories'
+import type {
+  Arity,
+  CljValue,
+  CljVector,
+  DestructurePattern,
+  Env,
+  EvaluationContext,
+} from '../types'
+import { destructureBindings } from './destructure'
+
+export class RecurSignal {
+  args: CljValue[]
+  constructor(args: CljValue[]) {
+    this.args = args
+  }
+}
+
+export function parseParamVector(
+  args: CljVector,
+  env: Env
+): { params: DestructurePattern[]; restParam: DestructurePattern | null } {
+  const ampIdx = args.value.findIndex((a) => isSymbol(a) && a.name === '&')
+  let params: DestructurePattern[] = []
+  let restParam: DestructurePattern | null = null
+  if (ampIdx === -1) {
+    params = args.value as DestructurePattern[]
+  } else {
+    const ampsCount = args.value.filter(
+      (a) => isSymbol(a) && a.name === '&'
+    ).length
+    if (ampsCount > 1) {
+      throw new EvaluationError('& can only appear once', { args, env })
+    }
+    if (ampIdx !== args.value.length - 2) {
+      throw new EvaluationError('& must be second-to-last argument', {
+        args,
+        env,
+      })
+    }
+    params = args.value.slice(0, ampIdx) as DestructurePattern[]
+    restParam = args.value[ampIdx + 1] as DestructurePattern
+  }
+  return { params, restParam }
+}
+
+export function parseArities(forms: CljValue[], env: Env): Arity[] {
+  if (forms.length === 0) {
+    throw new EvaluationError(
+      'fn/defmacro requires at least a parameter vector',
+      {
+        forms,
+        env,
+      }
+    )
+  }
+
+  if (isVector(forms[0])) {
+    const paramVec = forms[0]
+    const { params, restParam } = parseParamVector(paramVec, env)
+    return [{ params, restParam, body: forms.slice(1) }]
+  }
+
+  if (isList(forms[0])) {
+    const arities: Arity[] = []
+    for (const form of forms) {
+      if (!isList(form) || form.value.length === 0) {
+        throw new EvaluationError(
+          'Multi-arity clause must be a list starting with a parameter vector',
+          { form, env }
+        )
+      }
+      const paramVec = form.value[0]
+      if (!isVector(paramVec)) {
+        throw new EvaluationError(
+          'First element of arity clause must be a parameter vector',
+          { paramVec, env }
+        )
+      }
+      const { params, restParam } = parseParamVector(paramVec, env)
+      arities.push({ params, restParam, body: form.value.slice(1) })
+    }
+
+    const variadicCount = arities.filter((a) => a.restParam !== null).length
+    if (variadicCount > 1) {
+      throw new EvaluationError(
+        'At most one variadic arity is allowed per function',
+        { forms, env }
+      )
+    }
+
+    return arities
+  }
+
+  throw new EvaluationError(
+    'fn/defmacro expects a parameter vector or arity clauses',
+    { forms, env }
+  )
+}
+
+export function bindParams(
+  params: DestructurePattern[],
+  restParam: DestructurePattern | null,
+  args: CljValue[],
+  outerEnv: Env,
+  ctx: EvaluationContext,
+  bindEnv: Env
+): Env {
+  if (restParam === null) {
+    if (args.length !== params.length) {
+      throw new EvaluationError(
+        `Arguments length mismatch: fn accepts ${params.length} arguments, but ${args.length} were provided`,
+        { params, args, outerEnv }
+      )
+    }
+  } else {
+    if (args.length < params.length) {
+      throw new EvaluationError(
+        `Arguments length mismatch: fn expects at least ${params.length} arguments, but ${args.length} were provided`,
+        { params, args, outerEnv }
+      )
+    }
+  }
+
+  const allPairs: [string, CljValue][] = []
+
+  for (let i = 0; i < params.length; i++) {
+    allPairs.push(...destructureBindings(params[i], args[i], ctx, bindEnv))
+  }
+
+  if (restParam !== null) {
+    const restArgs = args.slice(params.length)
+    let restValue: CljValue
+    if (isMap(restParam) && restArgs.length > 0) {
+      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()
+    }
+    allPairs.push(...destructureBindings(restParam, restValue, ctx, bindEnv))
+  }
+
+  return extend(
+    allPairs.map(([n]) => n),
+    allPairs.map(([, v]) => v),
+    outerEnv
+  )
+}
+
+export function resolveArity(arities: Arity[], argCount: number): Arity {
+  const exactMatch = arities.find(
+    (a) => a.restParam === null && a.params.length === argCount
+  )
+  if (exactMatch) return exactMatch
+
+  const variadicMatch = arities.find(
+    (a) => a.restParam !== null && argCount >= a.params.length
+  )
+  if (variadicMatch) return variadicMatch
+
+  const counts = arities.map((a) =>
+    a.restParam ? `${a.params.length}+` : `${a.params.length}`
+  )
+  throw new EvaluationError(
+    `No matching arity for ${argCount} arguments. Available arities: ${counts.join(', ')}`,
+    { arities, argCount }
+  )
+}

package/src/core/evaluator/collections.ts

@@ -0,0 +1,25 @@
+import { cljMap, cljVector } from '../factories'
+import type { CljMap, CljValue, CljVector, EvaluationContext } from '../types'
+import type { Env } from '../types'
+
+export function evaluateVector(
+  vector: CljVector,
+  env: Env,
+  ctx: EvaluationContext
+): CljValue {
+  return cljVector(vector.value.map((v) => ctx.evaluate(v, env)))
+}
+
+export function evaluateMap(
+  map: CljMap,
+  env: Env,
+  ctx: EvaluationContext
+): CljValue {
+  let entries: [CljValue, CljValue][] = []
+  for (const [key, value] of map.entries) {
+    const evaluatedKey = ctx.evaluate(key, env)
+    const evaluatedValue = ctx.evaluate(value, env)
+    entries.push([evaluatedKey, evaluatedValue])
+  }
+  return cljMap(entries)
+}