conjure-js 0.0.12 → 0.0.13

package/src/core/stdlib/transducers.ts

@@ -1,21 +1,8 @@
 // Transducer protocol primitives: reduced, volatile!, transduce
 
-import {
-  isAFunction,
-  isNil,
-  isReduced,
-  isSeqable,
-  isVolatile,
-} from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import {
-  cljBoolean,
-  cljNativeFunction,
-  cljNativeFunctionWithContext,
-  cljReduced,
-  cljVolatile,
-  withDoc,
-} from '../factories'
+import { v } from '../factories'
 import { joinLines, printString } from '../printer'
 import { toSeq } from '../transformations'
 import type {
@@ -28,71 +15,76 @@ import type {
 
 export const transducerFunctions: Record<string, CljValue> = {
   // ── Reduced sentinel ────────────────────────────────────────────────────
-  reduced: withDoc(
-    cljNativeFunction('reduced', (value: CljValue) => {
+  reduced: v
+    .nativeFn('reduced', function reducedImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('reduced expects one argument', {})
       }
-      return cljReduced(value)
-    }),
-    'Returns a reduced value, indicating termination of the reduction process.',
-    [['value']]
-  ),
-  'reduced?': withDoc(
-    cljNativeFunction('reduced?', (value: CljValue) => {
+      return v.reduced(value)
+    })
+    .doc(
+      'Returns a reduced value, indicating termination of the reduction process.',
+      [['value']]
+    ),
+  'reduced?': v
+    .nativeFn('reduced?', function isReducedImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('reduced? expects one argument', {})
       }
-      return cljBoolean(isReduced(value))
-    }),
-    'Returns true if the given value is a reduced value, false otherwise.',
-    [['value']]
-  ),
-  unreduced: withDoc(
-    cljNativeFunction('unreduced', (value: CljValue) => {
+      return v.boolean(is.reduced(value))
+    })
+    .doc(
+      'Returns true if the given value is a reduced value, false otherwise.',
+      [['value']]
+    ),
+  unreduced: v
+    .nativeFn('unreduced', function unreducedImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('unreduced expects one argument', {})
       }
-      return isReduced(value) ? value.value : value
-    }),
-    'Returns the unreduced value of the given value. If the value is not a reduced value, it is returned unchanged.',
-    [['value']]
-  ),
-  'ensure-reduced': withDoc(
-    cljNativeFunction('ensure-reduced', (value: CljValue) => {
+      return is.reduced(value) ? value.value : value
+    })
+    .doc(
+      'Returns the unreduced value of the given value. If the value is not a reduced value, it is returned unchanged.',
+      [['value']]
+    ),
+  'ensure-reduced': v
+    .nativeFn('ensure-reduced', function ensureReducedImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('ensure-reduced expects one argument', {})
       }
-      return isReduced(value) ? value : cljReduced(value)
-    }),
-    'Returns the given value if it is a reduced value, otherwise returns a reduced value with the given value as its value.',
-    [['value']]
-  ),
+      return is.reduced(value) ? value : v.reduced(value)
+    })
+    .doc(
+      'Returns the given value if it is a reduced value, otherwise returns a reduced value with the given value as its value.',
+      [['value']]
+    ),
 
   // ── Volatile ─────────────────────────────────────────────────────────────
-  'volatile!': withDoc(
-    cljNativeFunction('volatile!', (value: CljValue) => {
+  'volatile!': v
+    .nativeFn('volatile!', function volatileImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('volatile! expects one argument', {})
       }
-      return cljVolatile(value)
-    }),
-    'Returns a volatile value with the given value as its value.',
-    [['value']]
-  ),
-  'volatile?': withDoc(
-    cljNativeFunction('volatile?', (value: CljValue) => {
+      return v.volatile(value)
+    })
+    .doc('Returns a volatile value with the given value as its value.', [
+      ['value'],
+    ]),
+  'volatile?': v
+    .nativeFn('volatile?', function isVolatileImpl(value: CljValue) {
       if (value === undefined) {
         throw new EvaluationError('volatile? expects one argument', {})
       }
-      return cljBoolean(isVolatile(value))
-    }),
-    'Returns true if the given value is a volatile value, false otherwise.',
-    [['value']]
-  ),
-  'vreset!': withDoc(
-    cljNativeFunction('vreset!', (vol: CljValue, newVal: CljValue) => {
-      if (!isVolatile(vol)) {
+      return v.boolean(is.volatile(value))
+    })
+    .doc(
+      'Returns true if the given value is a volatile value, false otherwise.',
+      [['value']]
+    ),
+  'vreset!': v
+    .nativeFn('vreset!', function vresetImpl(vol: CljValue, newVal: CljValue) {
+      if (!is.volatile(vol)) {
         throw new EvaluationError(
           `vreset! expects a volatile as its first argument, got ${printString(vol)}`,
           { vol }
@@ -103,27 +95,28 @@ export const transducerFunctions: Record<string, CljValue> = {
       }
       vol.value = newVal
       return newVal
-    }),
-    'Resets the value of the given volatile to the given new value and returns the new value.',
-    [['vol', 'newVal']]
-  ),
-  'vswap!': withDoc(
-    cljNativeFunctionWithContext(
+    })
+    .doc(
+      'Resets the value of the given volatile to the given new value and returns the new value.',
+      [['vol', 'newVal']]
+    ),
+  'vswap!': v
+    .nativeFnCtx(
       'vswap!',
-      (
+      function vswapImpl(
         ctx: EvaluationContext,
         callEnv: Env,
         vol: CljValue,
         fn: CljValue,
         ...extraArgs: CljValue[]
-      ) => {
-        if (!isVolatile(vol)) {
+      ) {
+        if (!is.volatile(vol)) {
           throw new EvaluationError(
             `vswap! expects a volatile as its first argument, got ${printString(vol)}`,
             { vol }
           )
         }
-        if (!isAFunction(fn)) {
+        if (!is.aFunction(fn)) {
           throw new EvaluationError(
             `vswap! expects a function as its second argument, got ${printString(fn)}`,
             { fn }
@@ -137,13 +130,14 @@ export const transducerFunctions: Record<string, CljValue> = {
         vol.value = newVal
         return newVal
       }
+    )
+    .doc(
+      'Applies fn to the current value of the volatile, replacing the current value with the result. Returns the new value.',
+      [
+        ['vol', 'fn'],
+        ['vol', 'fn', '&', 'extraArgs'],
+      ]
     ),
-    'Applies fn to the current value of the volatile, replacing the current value with the result. Returns the new value.',
-    [
-      ['vol', 'fn'],
-      ['vol', 'fn', '&', 'extraArgs'],
-    ]
-  ),
 
   // ── transduce ─────────────────────────────────────────────────────────────
 
@@ -153,24 +147,24 @@ export const transducerFunctions: Record<string, CljValue> = {
   // f    — bottom reducing function (must support 0-arity when used as 3-arity)
   // init — initial accumulator value
   // coll — source collection (nil is treated as empty)
-  transduce: withDoc(
-    cljNativeFunctionWithContext(
+  transduce: v
+    .nativeFnCtx(
       'transduce',
-      (
+      function transduceImpl(
         ctx: EvaluationContext,
         callEnv: Env,
         xform: CljValue,
         f: CljValue,
         init: CljValue,
         coll: CljValue
-      ) => {
-        if (!isAFunction(xform)) {
+      ) {
+        if (!is.aFunction(xform)) {
           throw new EvaluationError(
             `transduce expects a transducer (function) as first argument, got ${printString(xform)}`,
             { xf: xform }
           )
         }
-        if (!isAFunction(f)) {
+        if (!is.aFunction(f)) {
           throw new EvaluationError(
             `transduce expects a reducing function as second argument, got ${printString(f)}`,
             { f }
@@ -206,7 +200,7 @@ export const transducerFunctions: Record<string, CljValue> = {
         ) as CljFunction | CljNativeFunction
 
         // nil collection is treated as empty — skip loop, run completion only
-        if (isNil(actualColl)) {
+        if (is.nil(actualColl)) {
           return ctx.applyFunction(
             rf as CljFunction | CljNativeFunction,
             [actualInit],
@@ -214,7 +208,7 @@ export const transducerFunctions: Record<string, CljValue> = {
           )
         }
 
-        if (!isSeqable(actualColl)) {
+        if (!is.seqable(actualColl)) {
           throw new EvaluationError(
             `transduce expects a collection or string as ${coll === undefined ? 'third' : 'fourth'} argument, got ${printString(actualColl)}`,
             { coll: actualColl }
@@ -227,7 +221,7 @@ export const transducerFunctions: Record<string, CljValue> = {
         for (const item of items) {
           // 2-arity call on the composed rf
           const result = ctx.applyFunction(rf, [acc, item], callEnv)
-          if (isReduced(result)) {
+          if (is.reduced(result)) {
             acc = result.value
             break
           }
@@ -237,20 +231,21 @@ export const transducerFunctions: Record<string, CljValue> = {
         // Completion (1-arity call on the composed rf)
         return ctx.applyFunction(rf, [acc], callEnv)
       }
+    )
+    .doc(
+      joinLines([
+        'reduce with a transformation of f (xf). If init is not',
+        'supplied, (f) will be called to produce it. f should be a reducing',
+        'step function that accepts both 1 and 2 arguments, if it accepts',
+        "only 2 you can add the arity-1 with 'completing'. Returns the result",
+        'of applying (the transformed) xf to init and the first item in coll,',
+        'then applying xf to that result and the 2nd item, etc. If coll',
+        'contains no items, returns init and f is not called. Note that',
+        'certain transforms may inject or skip items.',
+      ]),
+      [
+        ['xform', 'f', 'coll'],
+        ['xform', 'f', 'init', 'coll'],
+      ]
     ),
-    joinLines([
-      'reduce with a transformation of f (xf). If init is not',
-      'supplied, (f) will be called to produce it. f should be a reducing',
-      'step function that accepts both 1 and 2 arguments, if it accepts',
-      "only 2 you can add the arity-1 with 'completing'. Returns the result",
-      'of applying (the transformed) xf to init and the first item in coll,',
-      'then applying xf to that result and the 2nd item, etc. If coll',
-      'contains no items, returns init and f is not called. Note that',
-      'certain transforms may inject or skip items.',
-    ]),
-    [
-      ['xform', 'f', 'coll'],
-      ['xform', 'f', 'init', 'coll'],
-    ]
-  ),
 }