conjure-js 0.0.13 → 0.0.14

package/src/core/session.ts

@@ -1,17 +1,17 @@
 import { builtInNamespaceSources } from '../clojure/generated/builtin-namespace-registry'
+import { cljToJs as _cljToJs } from './conversions'
+import { internVar, makeEnv } from './env'
 import { CljThrownSignal, EvaluationError, ReaderError } from './errors'
 import { createEvaluationContext, RecurSignal } from './evaluator'
-import { internVar, makeEnv } from './env'
-import { v } from './factories'
 import { jsToClj } from './evaluator/js-interop'
+import { v } from './factories'
 import type { RuntimeModule } from './module'
-import { cljToJs as _cljToJs } from './conversions'
+import { extractAliasMapFromTokens, extractNsNameFromTokens } from './ns-forms'
 import { formatErrorContext } from './positions'
 import { printString } from './printer'
 import { readForms } from './reader'
 import type { Runtime, RuntimeSnapshot } from './runtime'
 import { createRuntime, restoreRuntime } from './runtime'
-import { extractAliasMapFromTokens, extractNsNameFromTokens } from './ns-forms'
 import { tokenize } from './tokenizer'
 import type { CljNamespace, CljValue, Env } from './types'
 
@@ -57,7 +57,11 @@ export type Session = {
   getNs: (namespace: string) => CljNamespace | null
   loadFile: (source: string, nsName?: string, filePath?: string) => string
   /** Async variant of loadFile — handles string requires ((:require ["pkg" :as X])). */
-  loadFileAsync: (source: string, nsName?: string, filePath?: string) => Promise<string>
+  loadFileAsync: (
+    source: string,
+    nsName?: string,
+    filePath?: string
+  ) => Promise<string>
   evaluate: (
     source: string,
     opts?: { lineOffset?: number; colOffset?: number; file?: string }
@@ -142,7 +146,11 @@ function buildSessionFacade(
       return runtime.loadFile(source, nsName, filePath, ctx)
     },
 
-    async loadFileAsync(source: string, nsName?: string, filePath?: string): Promise<string> {
+    async loadFileAsync(
+      source: string,
+      nsName?: string,
+      filePath?: string
+    ): Promise<string> {
       // If there is no ns declaration in the source, pre-set the namespace from
       // the hint so the forms evaluate in the right context.
       if (nsName) {
@@ -301,7 +309,9 @@ function buildSessionFacade(
     },
 
     cljToJs(value: CljValue): unknown {
-      return _cljToJs(value, { applyFunction: (fn, args) => ctx.applyCallable(fn, args, makeEnv()) })
+      return _cljToJs(value, {
+        applyFunction: (fn, args) => ctx.applyCallable(fn, args, makeEnv()),
+      })
     },
 
     evaluateForms(forms: CljValue[]): CljValue {

package/src/core/tokenizer.ts

@@ -1,6 +1,7 @@
 import { TokenizerError } from './errors'
 import { makeCharScanner, type CharScanner } from './scanners'
-import { tokenKeywords, tokenSymbols, type Token } from './types'
+import { tokenKeywords, tokenSymbols } from './keywords'
+import type { Token } from './types'
 
 export type TokensResult = {
   tokens: Token[]
@@ -169,9 +170,15 @@ const parseNumber = (ctx: TokenizationContext): Token => {
     value += scanner.advance()! // consume '.'
     value += scanner.consumeWhile(isNumber)
   }
-  if (!scanner.isAtEnd() && (scanner.peek() === 'e' || scanner.peek() === 'E')) {
+  if (
+    !scanner.isAtEnd() &&
+    (scanner.peek() === 'e' || scanner.peek() === 'E')
+  ) {
     value += scanner.advance()! // consume 'e' or 'E'
-    if (!scanner.isAtEnd() && (scanner.peek() === '+' || scanner.peek() === '-')) {
+    if (
+      !scanner.isAtEnd() &&
+      (scanner.peek() === '+' || scanner.peek() === '-')
+    ) {
       value += scanner.advance()! // consume optional sign
     }
     const exponentDigits = scanner.consumeWhile(isNumber)
@@ -226,7 +233,10 @@ const parseMetaToken = (ctx: TokenizationContext): Token => {
   return { kind: 'Meta', start, end: scanner.position() }
 }
 
-const parseRegexLiteral = (ctx: TokenizationContext, start: ReturnType<typeof ctx.scanner.position>): Token => {
+const parseRegexLiteral = (
+  ctx: TokenizationContext,
+  start: ReturnType<typeof ctx.scanner.position>
+): Token => {
   const scanner = ctx.scanner
   scanner.advance() // consume opening '"'
   const buffer: string[] = []

package/src/core/transformations.ts

@@ -1,8 +1,14 @@
-import { isCons, isLazySeq, isList, isMap, isNil, isSet, isVector } from './assertions'
+import { is } from './assertions'
 import { EvaluationError } from './errors'
-import { cljString, cljVector } from './factories'
-import { printString, getPrintContext } from './printer'
-import { type CljCons, type CljDelay, type CljLazySeq, type CljValue, valueKeywords } from './types'
+import { v } from './factories'
+import { valueKeywords } from './keywords'
+import { getPrintContext, printString } from './printer'
+import {
+  type CljCons,
+  type CljDelay,
+  type CljLazySeq,
+  type CljValue,
+} from './types'
 
 export function valueToString(value: CljValue): string {
   switch (value.kind) {
@@ -18,26 +24,36 @@ export function valueToString(value: CljValue): string {
       return value.name
     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 ? ' ...' : ''
+      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 ? ' ...' : ''
+      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 ? ' ...' : ''
+      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 ? ' ...' : ''
+      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: {
@@ -67,17 +83,20 @@ export function valueToString(value: CljValue): string {
       return `${prefix}${value.pattern}`
     }
     case valueKeywords.delay:
-      return value.realized ? `#<Delay @${valueToString(value.value!)}>` : '#<Delay pending>'
+      return value.realized
+        ? `#<Delay @${valueToString(value.value!)}>`
+        : '#<Delay pending>'
     case valueKeywords.lazySeq: {
       const realized = realizeLazySeq(value)
-      if (isNil(realized)) return '()'
+      if (is.nil(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 ? ' ...' : ''
+      const suffix =
+        printLength !== null && items.length > printLength ? ' ...' : ''
       return `(${visible.map(valueToString).join(' ')}${suffix})`
     }
     case valueKeywords.namespace:
@@ -123,27 +142,27 @@ export function realizeLazySeq(ls: CljLazySeq): CljValue {
 }
 
 export const toSeq = (collection: CljValue): CljValue[] => {
-  if (isList(collection)) {
+  if (is.list(collection)) {
     return collection.value
   }
-  if (isVector(collection)) {
+  if (is.vector(collection)) {
     return collection.value
   }
-  if (isMap(collection)) {
-    return collection.entries.map(([k, v]) => cljVector([k, v]))
+  if (is.map(collection)) {
+    return collection.entries.map(([key, value]) => v.vector([key, value]))
   }
-  if (isSet(collection)) {
+  if (is.set(collection)) {
     return collection.values
   }
   if (collection.kind === 'string') {
-    return [...collection.value].map(cljString)
+    return [...collection.value].map(v.string)
   }
-  if (isLazySeq(collection)) {
+  if (is.lazySeq(collection)) {
     const realized = realizeLazySeq(collection)
-    if (isNil(realized)) return []
+    if (is.nil(realized)) return []
     return toSeq(realized)
   }
-  if (isCons(collection)) {
+  if (is.cons(collection)) {
     return consToArray(collection)
   }
   throw new EvaluationError(
@@ -157,21 +176,21 @@ 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)) {
+    if (is.nil(tail)) break
+    if (is.cons(tail)) {
       result.push(tail.head)
       tail = tail.tail
       continue
     }
-    if (isLazySeq(tail)) {
+    if (is.lazySeq(tail)) {
       tail = realizeLazySeq(tail)
       continue
     }
-    if (isList(tail)) {
+    if (is.list(tail)) {
       result.push(...tail.value)
       break
     }
-    if (isVector(tail)) {
+    if (is.vector(tail)) {
       result.push(...tail.value)
       break
     }

package/src/core/types.ts

@@ -1,31 +1,3 @@
-export const valueKeywords = {
-  number: 'number',
-  string: 'string',
-  boolean: 'boolean',
-  keyword: 'keyword',
-  nil: 'nil',
-  symbol: 'symbol',
-  list: 'list',
-  vector: 'vector',
-  map: 'map',
-  function: 'function',
-  nativeFunction: 'native-function',
-  macro: 'macro',
-  multiMethod: 'multi-method',
-  atom: 'atom',
-  reduced: 'reduced',
-  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]
-
 export type CljNumber = { kind: 'number'; value: number }
 export type CljString = { kind: 'string'; value: string }
 export type CljBoolean = { kind: 'boolean'; value: boolean }
@@ -34,19 +6,23 @@ export type CljNil = { kind: 'nil'; value: null }
 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 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
-  readerAliases: Map<string, string>   // :as-alias reader aliases
+  vars: Map<string, CljVar> // user defs from (def ...)
+  aliases: Map<string, CljNamespace> // :as namespace aliases
+  readerAliases: Map<string, string> // :as-alias reader aliases
 }
 
 export type Env = {
-  bindings: Map<string, CljValue>      // native fns, macros, multimethods, local values
+  bindings: Map<string, CljValue> // native fns, macros, multimethods, local values
   outer: Env | null
-  ns?: CljNamespace                    // set on namespace-root envs only
+  ns?: CljNamespace // set on namespace-root envs only
 }
 
 export type DestructurePattern = CljSymbol | CljVector | CljMap
@@ -55,13 +31,14 @@ export type Arity = {
   params: DestructurePattern[]
   restParam: DestructurePattern | null
   body: CljValue[]
+  compiledBody?: CompiledExpr
 }
 
 export type CljFunction = {
   kind: 'function'
   arities: Arity[]
   env: Env
-  name?: string   // set for named fn: (fn my-name [x] x)
+  name?: string // set for named fn: (fn my-name [x] x)
   meta?: CljMap
 }
 
@@ -69,14 +46,17 @@ export type CljMacro = {
   kind: 'macro'
   arities: Arity[]
   env: Env
-  name?: string   // set for named defmacro
+  name?: string // set for named defmacro
 }
 
 export type CljAtom = {
   kind: 'atom'
   value: CljValue
   meta?: CljMap
-  watches?: Map<string, { key: CljValue; fn: CljValue; ctx: EvaluationContext; callEnv: Env }>
+  watches?: Map<
+    string,
+    { key: CljValue; fn: CljValue; ctx: EvaluationContext; callEnv: Env }
+  >
   validator?: CljValue
 }
 export type CljReduced = { kind: 'reduced'; value: CljValue }
@@ -96,13 +76,13 @@ export type CljLazySeq = {
   kind: 'lazy-seq'
   thunk: (() => CljValue) | null
   realized: boolean
-  value?: CljValue  // nil, list, cons, or another lazy-seq after realization
+  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
+  tail: CljValue // can be list, vector, lazy-seq, cons, or nil
   meta?: CljMap
 }
 
@@ -111,8 +91,8 @@ export type CljVar = {
   ns: string
   name: string
   value: CljValue
-  dynamic?: boolean          // set when def is annotated with ^:dynamic
-  bindingStack?: CljValue[]  // active dynamic bindings (push/pop by `binding`)
+  dynamic?: boolean // set when def is annotated with ^:dynamic
+  bindingStack?: CljValue[] // active dynamic bindings (push/pop by `binding`)
   meta?: CljMap
 }
 
@@ -234,46 +214,6 @@ export type CljValue =
   | CljPending
   | CljJsValue
 
-/** Tokens */
-export const tokenKeywords = {
-  LParen: 'LParen',
-  RParen: 'RParen',
-  LBracket: 'LBracket',
-  RBracket: 'RBracket',
-  LBrace: 'LBrace',
-  RBrace: 'RBrace',
-  String: 'String',
-  Number: 'Number',
-  Keyword: 'Keyword',
-  Quote: 'Quote',
-  Quasiquote: 'Quasiquote',
-  Unquote: 'Unquote',
-  UnquoteSplicing: 'UnquoteSplicing',
-  Comment: 'Comment',
-  Whitespace: 'Whitespace',
-  Symbol: 'Symbol',
-  AnonFnStart: 'AnonFnStart',
-  Deref: 'Deref',
-  Regex: 'Regex',
-  VarQuote: 'VarQuote',
-  Meta: 'Meta',
-  SetStart: 'SetStart',
-} as const
-export const tokenSymbols = {
-  Quote: 'quote',
-  Quasiquote: 'quasiquote',
-  Unquote: 'unquote',
-  UnquoteSplicing: 'unquote-splicing',
-  LParen: '(',
-  RParen: ')',
-  LBracket: '[',
-  RBracket: ']',
-  LBrace: '{',
-  RBrace: '}',
-} as const
-export type TokenSymbols = (typeof tokenSymbols)[keyof typeof tokenSymbols]
-export type TokenKinds = keyof typeof tokenKeywords
-
 export type Cursor = {
   line: number
   col: number
@@ -388,3 +328,39 @@ export type Token = (
   | TokenMeta
   | TokenSetStart
 ) & { start: Cursor; end: Cursor }
+
+/** Compiler */
+
+/**
+ * A compiled expression takes runtime env + ctx, returns a CljValue.
+ * Signature includes ctx even though we don't use it yet
+ * Phases 2+ (if, fn*, apply) will need it. We keep the shape fixed now.
+ */
+export type CompiledExpr = (env: Env, ctx: EvaluationContext) => CljValue
+
+/**
+ * A compile function takes a node and an optional compile-time env. It returns a compiled expression
+ * when it can't compile a node, it returns null, falling back to the interpreter
+ * we have this definition here so that recursive compiler functions such as compileIf,
+ * and compileDo can reference the "root dispatcher" when compiling sub-forms.
+ * It's a clean way to prevent cyclical dependencies. Only recursive compiler fns need this.
+ */
+export type CompileFn = (
+  node: CljValue,
+  env: CompileEnv | null
+) => CompiledExpr | null
+
+/**
+ * A mutable box. Allocated at compile time.
+ * Read by compiled symbols that reference the slot binding.
+ */
+export type SlotRef = { value: CljValue | null }
+
+export type CompileEnv = {
+  bindings: Map<string, SlotRef>
+  outer: CompileEnv | null
+  loop?: {
+    slots: SlotRef[]
+    recurTarget: { args: CljValue[] | null }
+  }
+}