conjure-js 0.0.1

package/src/core/factories.ts

@@ -0,0 +1,155 @@
+import { EvaluationError } from './errors'
+import type {
+  Arity,
+  CljAtom,
+  CljBoolean,
+  CljFunction,
+  CljKeyword,
+  CljList,
+  CljMacro,
+  CljMap,
+  CljMultiMethod,
+  CljNativeFunction,
+  CljNil,
+  CljNumber,
+  CljReduced,
+  CljRegex,
+  CljString,
+  CljSymbol,
+  CljValue,
+  CljVector,
+  CljVolatile,
+  DestructurePattern,
+  Env,
+  EvaluationContext,
+} from './types'
+
+export const cljNumber = <T extends number>(value: T) =>
+  ({ kind: 'number', value }) as const satisfies CljNumber
+export const cljString = <T extends string>(value: T) =>
+  ({ kind: 'string', value }) as const satisfies CljString
+export const cljBoolean = <T extends boolean>(value: T) =>
+  ({ kind: 'boolean', value }) as const satisfies CljBoolean
+export const cljKeyword = <T extends string>(name: T) =>
+  ({ kind: 'keyword', name }) as const satisfies CljKeyword
+export const cljNil = () =>
+  ({ kind: 'nil', value: null }) as const satisfies CljNil
+export const cljSymbol = <T extends string>(name: T) =>
+  ({ kind: 'symbol', name }) as const satisfies CljSymbol
+export const cljList = <T extends CljValue[]>(value: T) =>
+  ({ kind: 'list', value }) as const satisfies CljList
+export const cljVector = <T extends CljValue[]>(value: T) =>
+  ({ kind: 'vector', value }) as const satisfies CljVector
+export const cljMap = <T extends [CljValue, CljValue][]>(entries: T) =>
+  ({ kind: 'map', entries }) as const satisfies CljMap
+export const cljFunction = (
+  params: DestructurePattern[],
+  restParam: DestructurePattern | null,
+  body: CljValue[],
+  env: Env
+): CljFunction => ({
+  kind: 'function',
+  arities: [{ params, restParam, body }],
+  env,
+})
+export const cljMultiArityFunction = (
+  arities: Arity[],
+  env: Env
+): CljFunction => ({
+  kind: 'function',
+  arities,
+  env,
+})
+export const cljNativeFunction = <
+  T extends string,
+  U extends (...args: CljValue[]) => CljValue,
+>(
+  name: T,
+  fn: U
+) =>
+  ({ kind: 'native-function', name, fn }) as const satisfies CljNativeFunction
+export const cljNativeFunctionWithContext = <
+  T extends string,
+  U extends (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => CljValue,
+>(
+  name: T,
+  fn: U
+) =>
+  ({
+    kind: 'native-function',
+    name,
+    // for now wrap this, we won't use it
+    fn: () => {
+      throw new EvaluationError('Native function called without context', {
+        name,
+      })
+    },
+    fnWithContext: fn,
+  }) as const satisfies CljNativeFunction
+
+export const cljMacro = (
+  params: DestructurePattern[],
+  restParam: DestructurePattern | null,
+  body: CljValue[],
+  env: Env
+): CljMacro => ({
+  kind: 'macro',
+  arities: [{ params, restParam, body }],
+  env,
+})
+export const cljMultiArityMacro = (arities: Arity[], env: Env): CljMacro => ({
+  kind: 'macro',
+  arities,
+  env,
+})
+
+export const cljRegex = (pattern: string, flags: string = ''): CljRegex => ({
+  kind: 'regex',
+  pattern,
+  flags,
+})
+
+export const cljAtom = (value: CljValue): CljAtom => ({ kind: 'atom', value })
+export const cljReduced = (value: CljValue): CljReduced => ({
+  kind: 'reduced',
+  value,
+})
+export const cljVolatile = (value: CljValue): CljVolatile => ({
+  kind: 'volatile',
+  value,
+})
+
+export const withDoc = <T extends CljNativeFunction | CljFunction>(
+  fn: T,
+  doc: string,
+  arglists?: string[][]
+): T => ({
+  ...fn,
+  meta: cljMap([
+    [cljKeyword(':doc'), cljString(doc)],
+    ...(arglists
+      ? ([
+          [
+            cljKeyword(':arglists'),
+            cljVector(arglists.map((args) => cljVector(args.map(cljSymbol)))),
+          ],
+        ] as [CljValue, CljValue][])
+      : []),
+  ]),
+})
+
+export const cljMultiMethod = (
+  name: string,
+  dispatchFn: CljFunction | CljNativeFunction,
+  methods: Array<{
+    dispatchVal: CljValue
+    fn: CljFunction | CljNativeFunction
+  }>,
+  defaultMethod?: CljFunction | CljNativeFunction
+): CljMultiMethod => ({
+  kind: 'multi-method',
+  name,
+  dispatchFn,
+  methods,
+  defaultMethod,
+})

package/src/core/gensym.ts

@@ -0,0 +1,9 @@
+let _counter = 0
+
+export function makeGensym(prefix = 'G'): string {
+  return `${prefix}__${_counter++}`
+}
+
+export function resetGensymCounter(): void {
+  _counter = 0
+}

package/src/core/index.ts

@@ -0,0 +1,76 @@
+// Session API
+export { createSession, snapshotSession, createSessionFromSnapshot } from './session'
+export type { Session, SessionSnapshot } from './session'
+
+// Conversions
+export { cljToJs, jsToClj, ConversionError } from './conversions'
+
+// Evaluator
+export { applyFunction, applyMacro, evaluateWithMeasurements } from './evaluator'
+
+// Errors
+export { EvaluationError, ReaderError, TokenizerError } from './errors'
+
+// Factories
+export {
+  cljNumber,
+  cljString,
+  cljBoolean,
+  cljKeyword,
+  cljNil,
+  cljSymbol,
+  cljList,
+  cljVector,
+  cljMap,
+  cljFunction,
+  cljMultiArityFunction,
+  cljNativeFunction,
+  cljMacro,
+  cljMultiArityMacro,
+} from './factories'
+
+// Assertions
+export {
+  isCljValue,
+  isFalsy,
+  isTruthy,
+  isSymbol,
+  isVector,
+  isList,
+  isMap,
+  isKeyword,
+  isFunction,
+  isNativeFunction,
+  isMacro,
+  isAFunction,
+  isCollection,
+  isEqual,
+} from './assertions'
+
+// Env
+export { define } from './env'
+
+// Transformations
+export { valueToString } from './transformations'
+
+// Printer
+export { printString } from './printer'
+
+// Types
+export type {
+  CljValue,
+  CljNumber,
+  CljString,
+  CljBoolean,
+  CljKeyword,
+  CljNil,
+  CljSymbol,
+  CljList,
+  CljVector,
+  CljMap,
+  CljFunction,
+  CljNativeFunction,
+  CljMacro,
+  Env,
+  Arity,
+} from './types'

package/src/core/positions.ts

@@ -0,0 +1,38 @@
+import type { CljValue, Pos } from './types'
+
+export function setPos(val: CljValue, pos: Pos): void {
+  Object.defineProperty(val, '_pos', {
+    value: pos,
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  })
+}
+
+export function getPos(val: CljValue): Pos | undefined {
+  return (val as unknown as { _pos?: Pos })._pos
+}
+
+export function getLineCol(
+  source: string,
+  offset: number
+): { line: number; col: number; lineText: string } {
+  const lines = source.split('\n')
+  let pos = 0
+  for (let i = 0; i < lines.length; i++) {
+    const lineEnd = pos + lines[i].length
+    if (offset <= lineEnd) {
+      return { line: i + 1, col: offset - pos, lineText: lines[i] }
+    }
+    pos = lineEnd + 1 // +1 for the consumed '\n'
+  }
+  const last = lines[lines.length - 1]
+  return { line: lines.length, col: last.length, lineText: last }
+}
+
+export function formatErrorContext(source: string, pos: Pos): string {
+  const { line, col, lineText } = getLineCol(source, pos.start)
+  const span = Math.max(1, pos.end - pos.start)
+  const caret = ' '.repeat(col) + '^'.repeat(span)
+  return `\n  at line ${line}, col ${col + 1}:\n  ${lineText}\n  ${caret}`
+}

package/src/core/printer.ts

@@ -0,0 +1,86 @@
+import { EvaluationError } from './errors'
+import { valueKeywords, type CljMultiMethod, type CljValue } from './types'
+
+export function printString(value: CljValue): string {
+  switch (value.kind) {
+    case valueKeywords.number:
+      return value.value.toString()
+    case valueKeywords.string:
+      let escapedBuffer = ''
+      for (const char of value.value) {
+        switch (char) {
+          case '"':
+            escapedBuffer += '\\"'
+            break
+          case '\\':
+            escapedBuffer += '\\\\'
+            break
+          case '\n':
+            escapedBuffer += '\\n'
+            break
+          case '\r':
+            escapedBuffer += '\\r'
+            break
+          case '\t':
+            escapedBuffer += '\\t'
+            break
+          default:
+            escapedBuffer += char
+        }
+      }
+      return `"${escapedBuffer}"`
+    case valueKeywords.boolean:
+      return value.value ? 'true' : 'false'
+    case valueKeywords.nil:
+      return 'nil'
+    case valueKeywords.keyword:
+      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.function: {
+      if (value.arities.length === 1) {
+        const a = value.arities[0]
+        const params = a.restParam
+          ? [...a.params, { kind: 'symbol' as const, name: '&' }, a.restParam]
+          : a.params
+        return `(fn [${params.map(printString).join(' ')}] ${a.body.map(printString).join(' ')})`
+      }
+      const clauses = value.arities.map((a) => {
+        const params = a.restParam
+          ? [...a.params, { kind: 'symbol' as const, name: '&' }, a.restParam]
+          : a.params
+        return `([${params.map(printString).join(' ')}] ${a.body.map(printString).join(' ')})`
+      })
+      return `(fn ${clauses.join(' ')})`
+    }
+    case valueKeywords.nativeFunction:
+      return `(native-fn ${value.name})`
+    case valueKeywords.multiMethod:
+      return `(multi-method ${(value as CljMultiMethod).name})`
+    case valueKeywords.atom:
+      return `#<Atom ${printString(value.value)}>`
+    case valueKeywords.reduced:
+      return `#<Reduced ${printString(value.value)}>`
+    case valueKeywords.volatile:
+      return `#<Volatile ${printString(value.value)}>`
+    case valueKeywords.regex: {
+      const escaped = value.pattern.replace(/"/g, '\\"')
+      const prefix = value.flags ? `(?${value.flags})` : ''
+      return `#"${prefix}${escaped}"`
+    }
+    default:
+      throw new EvaluationError(`unhandled value type: ${value.kind}`, {
+        value,
+      })
+  }
+}
+
+export function joinLines(lines: string[]): string {
+  return lines.join('\n')
+}