conjure-js 0.0.1

package/src/core/stdlib/errors.ts

@@ -0,0 +1,81 @@
+import { CljThrownSignal, EvaluationError } from '../errors'
+import { cljKeyword, cljMap, cljNativeFunction, cljNil, withDoc } from '../factories'
+import { isKeyword, isMap } from '../assertions'
+import type { CljValue } from '../types'
+
+export const errorFunctions = {
+  throw: withDoc(
+    cljNativeFunction('throw', (...args: CljValue[]) => {
+      if (args.length !== 1) {
+        throw new EvaluationError(
+          `throw requires exactly 1 argument, got ${args.length}`,
+          { args }
+        )
+      }
+      throw new CljThrownSignal(args[0])
+    }),
+    'Throws a value as an exception. The value may be any CljValue; maps are idiomatic.',
+    [['value']]
+  ),
+
+  'ex-info': withDoc(
+    cljNativeFunction('ex-info', (...args: CljValue[]) => {
+      if (args.length < 2) {
+        throw new EvaluationError(
+          `ex-info requires at least 2 arguments, got ${args.length}`,
+          { args }
+        )
+      }
+      const [msg, data, cause] = args
+      if (msg.kind !== 'string') {
+        throw new EvaluationError(
+          'ex-info: first argument must be a string',
+          { msg }
+        )
+      }
+      const entries: [CljValue, CljValue][] = [
+        [cljKeyword(':message'), msg],
+        [cljKeyword(':data'), data],
+      ]
+      if (cause !== undefined) {
+        entries.push([cljKeyword(':cause'), cause])
+      }
+      return cljMap(entries)
+    }),
+    'Creates an error map with :message and :data keys. Optionally accepts a :cause.',
+    [['msg', 'data'], ['msg', 'data', 'cause']]
+  ),
+
+  'ex-message': withDoc(
+    cljNativeFunction('ex-message', (...args: CljValue[]) => {
+      const [e] = args
+      if (!isMap(e)) return cljNil()
+      const entry = e.entries.find(([k]) => isKeyword(k) && k.name === ':message')
+      return entry ? entry[1] : cljNil()
+    }),
+    'Returns the :message of an error map, or nil.',
+    [['e']]
+  ),
+
+  'ex-data': withDoc(
+    cljNativeFunction('ex-data', (...args: CljValue[]) => {
+      const [e] = args
+      if (!isMap(e)) return cljNil()
+      const entry = e.entries.find(([k]) => isKeyword(k) && k.name === ':data')
+      return entry ? entry[1] : cljNil()
+    }),
+    'Returns the :data map of an error map, or nil.',
+    [['e']]
+  ),
+
+  'ex-cause': withDoc(
+    cljNativeFunction('ex-cause', (...args: CljValue[]) => {
+      const [e] = args
+      if (!isMap(e)) return cljNil()
+      const entry = e.entries.find(([k]) => isKeyword(k) && k.name === ':cause')
+      return entry ? entry[1] : cljNil()
+    }),
+    'Returns the :cause of an error map, or nil.',
+    [['e']]
+  ),
+}

package/src/core/stdlib/hof.ts

@@ -0,0 +1,307 @@
+// Higher-order functions: map, filter, reduce, apply, partial, comp,
+// map-indexed, identity
+import {
+  isAFunction,
+  isCallable,
+  isNil,
+  isReduced,
+  isSeqable,
+} from '../assertions'
+import { EvaluationError } from '../errors'
+import {
+  cljNativeFunction,
+  cljNativeFunctionWithContext,
+  withDoc,
+} from '../factories'
+import { printString } from '../printer'
+import { toSeq } from '../transformations'
+import type { CljValue, Env, EvaluationContext } from '../types'
+
+export const hofFunctions: Record<string, CljValue> = {
+  // map: cljNativeFunctionWithContext(
+  //   'map',
+  //   (
+  //     ctx: EvaluationContext,
+  //     fn: CljValue | undefined,
+  //     collection: CljValue | undefined
+  //   ): CljValue => {
+  //     if (fn === undefined) {
+  //       throw new EvaluationError(
+  //         `map expects a function as first argument, got nil`,
+  //         { fn }
+  //       )
+  //     }
+  //     if (!isAFunction(fn)) {
+  //       throw new EvaluationError(
+  //         `map expects a function as first argument, got ${printString(fn)}`,
+  //         { fn }
+  //       )
+  //     }
+  //     if (collection === undefined) {
+  //       return cljNil()
+  //     }
+  //     if (!isCollection(collection)) {
+  //       throw new EvaluationError(
+  //         `map expects a collection, got ${printString(collection)}`,
+  //         { collection }
+  //       )
+  //     }
+
+  //     const wrap = isVector(collection) ? cljVector : cljList
+  //     return wrap(
+  //       toSeq(collection).map((item) => ctx.applyFunction(fn, [item]))
+  //     )
+  //   }
+  // ),
+  // filter: cljNativeFunctionWithContext(
+  //   'filter',
+  //   (
+  //     ctx: EvaluationContext,
+  //     fn: CljValue | undefined,
+  //     collection: CljValue | undefined
+  //   ): CljValue => {
+  //     if (fn === undefined) {
+  //       throw new EvaluationError(
+  //         `filter expects a function as first argument, got nil`,
+  //         { fn }
+  //       )
+  //     }
+  //     if (!isAFunction(fn)) {
+  //       throw new EvaluationError(
+  //         `filter expects a function as first argument, got ${printString(fn)}`,
+  //         { fn }
+  //       )
+  //     }
+  //     if (collection === undefined) {
+  //       return cljNil()
+  //     }
+  //     if (!isCollection(collection)) {
+  //       throw new EvaluationError(
+  //         `filter expects a collection, got ${printString(collection)}`,
+  //         { collection }
+  //       )
+  //     }
+
+  //     const wrap = isVector(collection) ? cljVector : cljList
+  //     return wrap(
+  //       toSeq(collection).filter((item) =>
+  //         isTruthy(ctx.applyFunction(fn, [item]))
+  //       )
+  //     )
+  //   }
+  // ),
+  reduce: withDoc(
+    cljNativeFunctionWithContext(
+      'reduce',
+      (
+        ctx: EvaluationContext,
+        callEnv: Env,
+        fn: CljValue,
+        ...rest: CljValue[]
+      ) => {
+        if (fn === undefined || !isAFunction(fn)) {
+          throw new EvaluationError(
+            `reduce expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
+            { fn }
+          )
+        }
+        if (rest.length === 0 || rest.length > 2) {
+          throw new EvaluationError(
+            'reduce expects 2 or 3 arguments: (reduce f coll) or (reduce f init coll)',
+            { fn }
+          )
+        }
+
+        const hasInit = rest.length === 2
+        const init: CljValue | undefined = hasInit ? rest[0] : undefined
+        const collection = hasInit ? rest[1] : rest[0]
+
+        // nil is treated as an empty collection (matches Clojure semantics)
+        if (collection.kind === 'nil') {
+          if (!hasInit) {
+            throw new EvaluationError(
+              'reduce called on empty collection with no initial value',
+              { fn }
+            )
+          }
+          return init!
+        }
+
+        if (!isSeqable(collection)) {
+          throw new EvaluationError(
+            `reduce expects a collection or string, got ${printString(collection)}`,
+            { collection }
+          )
+        }
+
+        const items = toSeq(collection)
+
+        if (!hasInit) {
+          if (items.length === 0) {
+            throw new EvaluationError(
+              'reduce called on empty collection with no initial value',
+              { fn }
+            )
+          }
+          if (items.length === 1) return items[0]
+          let acc = items[0]
+          for (let i = 1; i < items.length; i++) {
+            const result = ctx.applyFunction(fn, [acc, items[i]], callEnv)
+            if (isReduced(result)) return result.value
+            acc = result
+          }
+          return acc
+        }
+
+        let acc = init!
+        for (const item of items) {
+          const result = ctx.applyFunction(fn, [acc, item], callEnv)
+          if (isReduced(result)) return result.value
+          acc = result
+        }
+        return acc
+      }
+    ),
+    'Reduces a collection to a single value by iteratively applying f. (reduce f coll) or (reduce f init coll).',
+    [
+      ['f', 'coll'],
+      ['f', 'val', 'coll'],
+    ]
+  ),
+
+  apply: withDoc(
+    cljNativeFunctionWithContext(
+      'apply',
+      (
+        ctx: EvaluationContext,
+        callEnv: Env,
+        fn: CljValue | undefined,
+        ...rest: CljValue[]
+      ) => {
+        if (fn === undefined || !isCallable(fn)) {
+          throw new EvaluationError(
+            `apply expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
+            { fn }
+          )
+        }
+        if (rest.length === 0) {
+          throw new EvaluationError('apply expects at least 2 arguments', {
+            fn,
+          })
+        }
+        const lastArg = rest[rest.length - 1]
+        if (!isNil(lastArg) && !isSeqable(lastArg)) {
+          throw new EvaluationError(
+            `apply expects a collection or string as last argument, got ${printString(lastArg)}`,
+            { lastArg }
+          )
+        }
+
+        const args = [
+          ...rest.slice(0, -1),
+          ...(isNil(lastArg) ? [] : toSeq(lastArg)),
+        ]
+        return ctx.applyCallable(fn, args, callEnv)
+      }
+    ),
+    'Calls f with the elements of the last argument (a collection) as its arguments, optionally prepended by fixed args.',
+    [
+      ['f', 'args'],
+      ['f', '&', 'args'],
+    ]
+  ),
+
+  partial: withDoc(
+    cljNativeFunction('partial', (fn: CljValue, ...preArgs: CljValue[]) => {
+      if (fn === undefined || !isCallable(fn)) {
+        throw new EvaluationError(
+          `partial expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
+          { fn }
+        )
+      }
+      const capturedFn = fn
+      return cljNativeFunctionWithContext(
+        'partial',
+        (ctx: EvaluationContext, callEnv: Env, ...moreArgs: CljValue[]) => {
+          return ctx.applyCallable(
+            capturedFn,
+            [...preArgs, ...moreArgs],
+            callEnv
+          )
+        }
+      )
+    }),
+    'Returns a function that calls f with pre-applied args prepended to any additional arguments.',
+    [['f', '&', 'args']]
+  ),
+
+  comp: withDoc(
+    cljNativeFunction('comp', (...fns: CljValue[]) => {
+      if (fns.length === 0) {
+        return cljNativeFunction('identity', (x: CljValue) => x)
+      }
+      if (fns.some((f) => !isCallable(f))) {
+        throw new EvaluationError(
+          'comp expects functions or other callable values (keywords, maps)',
+          { fns }
+        )
+      }
+      const capturedFns = fns
+      return cljNativeFunctionWithContext(
+        'composed',
+        (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => {
+          let result = ctx.applyCallable(
+            capturedFns[capturedFns.length - 1],
+            args,
+            callEnv
+          )
+          for (let i = capturedFns.length - 2; i >= 0; i--) {
+            result = ctx.applyCallable(capturedFns[i], [result], callEnv)
+          }
+          return result
+        }
+      )
+    }),
+    'Returns the composition of fns, applied right-to-left. (comp f g) is equivalent to (fn [x] (f (g x))). Accepts any callable: functions, keywords, and maps.',
+    [[], ['f'], ['f', 'g'], ['f', 'g', '&', 'fns']]
+  ),
+
+  // 'map-indexed': cljNativeFunctionWithContext(
+  //   'map-indexed',
+  //   (ctx: EvaluationContext, fn: CljValue, coll: CljValue): CljValue => {
+  //     if (fn === undefined || !isAFunction(fn)) {
+  //       throw new EvaluationError(
+  //         `map-indexed expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
+  //         { fn }
+  //       )
+  //     }
+  //     if (coll === undefined || !isCollection(coll)) {
+  //       throw new EvaluationError(
+  //         `map-indexed expects a collection as second argument${coll !== undefined ? `, got ${printString(coll)}` : ''}`,
+  //         { coll }
+  //       )
+  //     }
+  //     const items = toSeq(coll)
+  //     const wrap = isVector(coll) ? cljVector : cljList
+  //     return wrap(
+  //       items.map((item, idx) =>
+  //         ctx.applyFunction(fn as CljFunction | CljNativeFunction, [
+  //           cljNumber(idx),
+  //           item,
+  //         ])
+  //       )
+  //     )
+  //   }
+  // ),
+
+  identity: withDoc(
+    cljNativeFunction('identity', (x: CljValue) => {
+      if (x === undefined) {
+        throw new EvaluationError('identity expects one argument', {})
+      }
+      return x
+    }),
+    'Returns its single argument unchanged.',
+    [['x']]
+  ),
+}

package/src/core/stdlib/meta.ts

@@ -0,0 +1,48 @@
+// Metadata: with-meta, meta
+import { EvaluationError } from '../errors'
+import { cljNativeFunction, cljNil, withDoc } from '../factories'
+import { printString } from '../printer'
+import type { CljMap, CljValue } from '../types'
+
+export const metaFunctions: Record<string, CljValue> = {
+  meta: withDoc(
+    cljNativeFunction('meta', (val: CljValue) => {
+      if (val === undefined) {
+        throw new EvaluationError('meta expects one argument', {})
+      }
+      if (val.kind === 'function' || val.kind === 'native-function') {
+        return val.meta ?? cljNil()
+      }
+      return cljNil()
+    }),
+    'Returns the metadata map of a value, or nil if the value has no metadata.',
+    [['val']]
+  ),
+
+  'with-meta': withDoc(
+    cljNativeFunction('with-meta', (val: CljValue, m: CljValue) => {
+      if (val === undefined) {
+        throw new EvaluationError('with-meta expects two arguments', {})
+      }
+      if (m === undefined) {
+        throw new EvaluationError('with-meta expects two arguments', {})
+      }
+      if (m.kind !== 'map' && m.kind !== 'nil') {
+        throw new EvaluationError(
+          `with-meta expects a map as second argument, got ${printString(m)}`,
+          { m }
+        )
+      }
+      if (val.kind !== 'function' && val.kind !== 'native-function') {
+        throw new EvaluationError(
+          `with-meta only supports functions, got ${printString(val)}`,
+          { val }
+        )
+      }
+      const meta = m.kind === 'nil' ? undefined : (m as CljMap)
+      return { ...val, meta }
+    }),
+    'Returns a new value with the metadata map m applied to val.',
+    [['val', 'm']]
+  ),
+}

package/src/core/stdlib/predicates.ts

@@ -0,0 +1,240 @@
+// Predicates & logical: nil?, true?, false?, truthy?, falsy?, not, not=,
+// number?, string?, boolean?, vector?, list?, map?, keyword?, symbol?, fn?,
+// coll?, some, every?
+import {
+  isAFunction,
+  isCollection,
+  isEqual,
+  isFalsy,
+  isKeyword,
+  isSeqable,
+  isSymbol,
+  isTruthy,
+  isList,
+  isVector,
+  isMap,
+} from '../assertions'
+import { applyFunction } from '../evaluator'
+import { EvaluationError } from '../errors'
+import { cljBoolean, cljNativeFunction, cljNil, withDoc } from '../factories'
+import { printString } from '../printer'
+import { toSeq } from '../transformations'
+import type { CljValue } from '../types'
+
+export const predicateFunctions: Record<string, CljValue> = {
+  'nil?': withDoc(
+    cljNativeFunction('nil?', (arg: CljValue) => {
+      return cljBoolean(arg.kind === 'nil')
+    }),
+    'Returns true if the value is nil, false otherwise.',
+    [['arg']]
+  ),
+  'true?': withDoc(
+    cljNativeFunction('true?', (arg: CljValue) => {
+      // returns true if the value is a boolean and true
+      if (arg.kind !== 'boolean') {
+        return cljBoolean(false)
+      }
+      return cljBoolean(arg.value === true)
+    }),
+    'Returns true if the value is a boolean and true, false otherwise.',
+    [['arg']]
+  ),
+  'false?': withDoc(
+    cljNativeFunction('false?', (arg: CljValue) => {
+      // returns true if the value is a boolean and false
+      if (arg.kind !== 'boolean') {
+        return cljBoolean(false)
+      }
+      return cljBoolean(arg.value === false)
+    }),
+    'Returns true if the value is a boolean and false, false otherwise.',
+    [['arg']]
+  ),
+  'truthy?': withDoc(
+    cljNativeFunction('truthy?', (arg: CljValue) => {
+      return cljBoolean(isTruthy(arg))
+    }),
+    'Returns true if the value is not nil or false, false otherwise.',
+    [['arg']]
+  ),
+  'falsy?': withDoc(
+    cljNativeFunction('falsy?', (arg: CljValue) => {
+      return cljBoolean(isFalsy(arg))
+    }),
+    'Returns true if the value is nil or false, false otherwise.',
+    [['arg']]
+  ),
+  // not: withDoc(
+  //   cljNativeFunction('not', (arg: CljValue) => {
+  //     return cljBoolean(!isTruthy(arg))
+  //   }),
+  //   'Returns the negation of the truthiness of the value.',
+  //   [['arg']]
+  // ),
+  'not=': withDoc(
+    cljNativeFunction('not=', (...vals: CljValue[]) => {
+      if (vals.length < 2) {
+        throw new EvaluationError('not= expects at least two arguments', {
+          args: vals,
+        })
+      }
+      for (let i = 1; i < vals.length; i++) {
+        if (!isEqual(vals[i], vals[i - 1])) {
+          return cljBoolean(true)
+        }
+      }
+      return cljBoolean(false)
+    }),
+    'Returns true if any two adjacent arguments are not equal, false otherwise.',
+    [['&', 'vals']]
+  ),
+  'number?': withDoc(
+    cljNativeFunction('number?', (x: CljValue) =>
+      cljBoolean(x !== undefined && x.kind === 'number')
+    ),
+    'Returns true if the value is a number, false otherwise.',
+    [['x']]
+  ),
+
+  'string?': withDoc(
+    cljNativeFunction('string?', (x: CljValue) =>
+      cljBoolean(x !== undefined && x.kind === 'string')
+    ),
+    'Returns true if the value is a string, false otherwise.',
+    [['x']]
+  ),
+
+  'boolean?': withDoc(
+    cljNativeFunction('boolean?', (x: CljValue) =>
+      cljBoolean(x !== undefined && x.kind === 'boolean')
+    ),
+    'Returns true if the value is a boolean, false otherwise.',
+    [['x']]
+  ),
+
+  'vector?': withDoc(
+    cljNativeFunction('vector?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isVector(x))
+    ),
+    'Returns true if the value is a vector, false otherwise.',
+    [['x']]
+  ),
+
+  'list?': withDoc(
+    cljNativeFunction('list?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isList(x))
+    ),
+    'Returns true if the value is a list, false otherwise.',
+    [['x']]
+  ),
+
+  'map?': withDoc(
+    cljNativeFunction('map?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isMap(x))
+    ),
+    'Returns true if the value is a map, false otherwise.',
+    [['x']]
+  ),
+
+  'keyword?': withDoc(
+    cljNativeFunction('keyword?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isKeyword(x))
+    ),
+    'Returns true if the value is a keyword, false otherwise.',
+    [['x']]
+  ),
+
+  'qualified-keyword?': withDoc(
+    cljNativeFunction('qualified-keyword?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isKeyword(x) && x.name.includes('/'))
+    ),
+    'Returns true if the value is a qualified keyword, false otherwise.',
+    [['x']]
+  ),
+
+  'symbol?': withDoc(
+    cljNativeFunction('symbol?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isSymbol(x))
+    ),
+    'Returns true if the value is a symbol, false otherwise.',
+    [['x']]
+  ),
+
+  'qualified-symbol?': withDoc(
+    cljNativeFunction('qualified-symbol?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isSymbol(x) && x.name.includes('/'))
+    ),
+    'Returns true if the value is a qualified symbol, false otherwise.',
+    [['x']]
+  ),
+
+  'fn?': withDoc(
+    cljNativeFunction('fn?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isAFunction(x))
+    ),
+    'Returns true if the value is a function, false otherwise.',
+    [['x']]
+  ),
+
+  'coll?': withDoc(
+    cljNativeFunction('coll?', (x: CljValue) =>
+      cljBoolean(x !== undefined && isCollection(x))
+    ),
+    'Returns true if the value is a collection, false otherwise.',
+    [['x']]
+  ),
+  some: withDoc(
+    cljNativeFunction('some', (pred: CljValue, coll: CljValue): CljValue => {
+      if (pred === undefined || !isAFunction(pred)) {
+        throw new EvaluationError(
+          `some expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`,
+          { pred }
+        )
+      }
+      if (coll === undefined) {
+        return cljNil()
+      }
+      if (!isSeqable(coll)) {
+        throw new EvaluationError(
+          `some expects a collection or string as second argument, got ${printString(coll)}`,
+          { coll }
+        )
+      }
+      for (const item of toSeq(coll)) {
+        const result = applyFunction(pred, [item])
+        if (isTruthy(result)) {
+          return result
+        }
+      }
+      return cljNil()
+    }),
+    'Returns the first truthy result of applying pred to each item in coll, or nil if no item satisfies pred.',
+    [['pred', 'coll']]
+  ),
+
+  'every?': withDoc(
+    cljNativeFunction('every?', (pred: CljValue, coll: CljValue): CljValue => {
+      if (pred === undefined || !isAFunction(pred)) {
+        throw new EvaluationError(
+          `every? expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`,
+          { pred }
+        )
+      }
+      if (coll === undefined || !isSeqable(coll)) {
+        throw new EvaluationError(
+          `every? expects a collection or string as second argument${coll !== undefined ? `, got ${printString(coll)}` : ''}`,
+          { coll }
+        )
+      }
+      for (const item of toSeq(coll)) {
+        if (isFalsy(applyFunction(pred, [item]))) {
+          return cljBoolean(false)
+        }
+      }
+      return cljBoolean(true)
+    }),
+    'Returns true if all items in coll satisfy pred, false otherwise.',
+    [['pred', 'coll']]
+  ),
+}