@thi.ng/transducers 8.9.18 → 9.0.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-03-27T09:53:46Z
+- **Last updated**: 2024-04-08T14:59:29Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,22 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [9.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@9.0.0) (2024-04-08)
+
+#### 🛑 Breaking changes
+
+- update Reducer, Transducer and other types ([95c43f3](https://github.com/thi-ng/umbrella/commit/95c43f3))
+- BREAKING CHANGE: update generics in Reducer, Transducer and other types
+  - swap generic type args in `Reducer` and `IReducible` to be same order as in `Transducer`, `IXform`,
+    i.e. `Reducer<A, B>` maps items from type A to type B, **not** the other way (as was)!
+  - this new order is more logical, less confusing and also in line with upcoming async transducers pkg
+  - changes in userland should be minimal (if any), only impacted are custom reducer definitions
+  - update all pkg internal occurrences
+  - various other small refactorings, type/arg updates, e.g.
+    - add generics for `reduced()`/`ensureReduced()`/`unreduced()`
+    - update `step()` return type (incl. undefined)
+    - add `StructField` generics
+
 ### [8.9.6](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@8.9.6) (2024-02-22)
 
 #### ♻️ Refactoring

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 190 standalone projects, maintained as part
+> This is one of 191 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -16,9 +16,7 @@
 
 - [About](#about)
 - [Status](#status)
-  - [7.0.0 release](#700-release)
-  - [6.0.0 release](#600-release)
-  - [5.0.0 release](#500-release)
+  - [9.0.0 release](#900-release)
 - [Support packages](#support-packages)
 - [Related packages](#related-packages)
   - [Blog posts](#blog-posts)
@@ -67,23 +65,23 @@
 
 Lightweight transducer implementations for ES6 / TypeScript.
 
-This library provides altogether ~130 transducers, reducers, sequence
-generators (ES6 generators/iterators) and additional supporting
-functions for composing data transformation pipelines.
+This library provides altogether ~170 transducers, reducers, sequence generators
+(ES6 generators/iterators) and additional supporting functions for composing
+data transformation pipelines.
 
-The overall concept and many of the core functions offered here are
-directly inspired by the original Clojure implementation by Rich Hickey,
-though the implementation does heavily differ (also in contrast to some
-other JS based implementations) and dozens of less common, but generally
-highly useful operators have been added. See full list below.
+The overall concept and many of the core functions offered here are directly
+inspired by the original Clojure implementation by Rich Hickey, though the
+implementation does heavily differ (also in contrast to some other JS based
+implementations) and dozens of less common, but generally highly useful
+operators have been added. See full list below.
 
-Furthermore, most transducers & reducers provided here accept an
-optional input iterable, which allows them to be used directly as
-transformers instead of having to wrap them in one of the execution
-functions (i.e. `transduce()`/`transduceRight()`, `reduce()`/`reduceRight()`,
-`iterator()`, `run()`, `step()`). If called this way, transducer functions
-will return a transforming ES6 iterator (generator) and reducing functions
-will return a reduced result of the given input iterable.
+Furthermore, most transducers & reducers provided here accept an optional input
+iterable, which allows them to be used directly as transformers instead of
+having to wrap them in one of the execution functions (i.e.
+`transduce()`/`transduceRight()`, `reduce()`/`reduceRight()`, `iterator()`,
+`run()`, `step()`). If called this way, transducer functions will return a
+transforming ES6 iterator (generator) and reducing functions will return a
+reduced result of the given input iterable.
 
 ## Status
 
@@ -91,52 +89,20 @@ will return a reduced result of the given input iterable.
 
 [Search or submit any issues for this package](https://github.com/thi-ng/umbrella/issues?q=%5Btransducers%5D+in%3Atitle)
 
-### 7.0.0 release
+### 9.0.0 release
 
-Thanks to a [PR](https://github.com/thi-ng/umbrella/pull/223) and [related
-issue](https://github.com/thi-ng/umbrella/issues/186) by
-[@gavinpc-mindgrub](https://github.com/gavinpc-mindgrub), various transducers
-functions have been fixed for the case when they're invoked with an _empty_
-string as input iterable. Furthermore,
-[`flatten()`](https://docs.thi.ng/umbrella/transducers/functions/flatten.html) is
-_always_ treating strings as atomic values now, whereas before top-level strings
-would be split into individual characters.
-
-### 6.0.0 release
-
-BREAKING CHANGES:
-
-- The `interpolate` iterator for keyframe interpolation has been renamed
-  to `tween`. In its place there's a new higher order transducer called
-  `interpolate`, incl. syntax-sugar versions `interpolateHermite` and
-  `interpolateLinear`.
-- The previously deprecated `wrapLeft`, `wrapRight` and `wrapBoth`
-  iterators have been removed.
-- The `wrap` iterator has been renamed to `wrapSides` and has a new
-  signature/arguments, more aligned with the ones listed below.
-
-The following new iterators have been added:
-
-- `extendSides`
-- `padSides`
-- `symmetric`
-
-### 5.0.0 release
-
-Several previously included internal support functions have been
-migrated to the
-[@thi.ng/arrays](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays)
-package. You'll need to update your imports if you've been using any of
-these directly. Note that some of these functions also have changes to
-their arg order. See changelog.
-
-Functions using randomness now all support an optional PRNG
-implementation of the `IRandom` interface from the
-[@thi.ng/random](https://github.com/thi-ng/umbrella/tree/develop/packages/random)
-package.
+This release corrects a longstanding stylistic issue regarding the order of
+generic type args given to [`Reducer<A, B>`](#reducer), which now uses the
+swapped & more logical order (i.e. reduce from `A` to `B`) and is the same order
+of generic type args for `Transducer` and `AsyncTransducer` / `AsyncReducer` (in
+the [thi.ng/transducers-async
+package](https://github.com/thi-ng/umbrella/blob/develop/packages/transducers-async)).
+Most userland code should be unimpacted by this change - this is only a breaking
+change for custom reducer impls.
 
 ## Support packages
 
+- [@thi.ng/transducers-async](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers-async) - Async versions of various highly composable transducers, reducers and iterators
 - [@thi.ng/transducers-binary](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers-binary) - Binary data related transducers & reducers
 - [@thi.ng/transducers-fsm](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers-fsm) - Transducer-based Finite State Machine transformer
 - [@thi.ng/transducers-hdom](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers-hdom) - Transducer based UI updater for [@thi.ng/hdom](https://github.com/thi-ng/umbrella/tree/develop/packages/hdom)
@@ -165,7 +131,13 @@ package.
 yarn add @thi.ng/transducers
 ```
 
-ES module import:
+ESM import:
+
+```ts
+import * as tx from "@thi.ng/transducers";
+```
+
+Browser ESM import:
 
 ```html
 <script type="module" src="https://cdn.skypack.dev/@thi.ng/transducers"></script>
@@ -176,7 +148,7 @@ ES module import:
 For Node.js REPL:
 
 ```js
-const transducers = await import("@thi.ng/transducers");
+const tx = await import("@thi.ng/transducers");
 ```
 
 Package sizes (brotli'd, pre-treeshake): ESM: 8.89 KB
@@ -696,50 +668,52 @@ Apart from type aliases, the only real types defined are:
 #### Reducer
 
 Reducers are the core building blocks of transducers. Unlike other
-implementations using OOP approaches, a `Reducer` in this lib is a
-simple 3-element array of functions, each addressing a separate
-processing step.
+implementations using OOP approaches, a `Reducer` in this lib is a simple
+3-element array of functions, each addressing a separate processing step.
+
+The bundled reducers are all wrapped in functions to provide a uniform API (and
+some of them can be preconfigured and/or are stateful closures). However, it's
+completely fine to define stateless reducers as constant arrays.
+
+A `Reducer` is a 3-tuple of functions defining the different stages of a
+reduction process: A `Reducer<A, B>` reduces values of type A to a single value
+of type B.
+
+The tuple items/functions in order:
 
-Since v0.6.0 the bundled reducers are all wrapped in functions to
-provide a uniform API (and some of them can be preconfigured and/or are
-stateful closures). However, it's fine to define stateless reducers as
-constant arrays.
+1. Initialization function used to produce an initial default result (only used
+   if no such initial result was given by the user)
+2. Completion function to post-process an already reduced result (for most
+   reducers this is merely the identity function)
+3. Accumulation function, merging a new input value with the currently existing
+   (partially) reduced result/accumulator
 
 ```ts
-interface Reducer<A, B> extends Array<any> {
-    /**
-     * Initialization, e.g. to provide a suitable accumulator value,
-     * only called when no initial accumulator has been provided by user.
-     */
-    [0]: () => A;
-    /**
-     * Completion. When called usually just returns `acc`, but stateful
-     * transformers should flush/apply their outstanding results.
-     */
-    [1]: (acc: A) => A;
-    /**
-     * Reduction step. Combines new input with accumulator.
-     * If reduction should terminate early, wrap result via `reduced()`
-     */
-    [2]: (acc: A, x: B) => A | Reduced<A>;
-}
+type Reducer<A, B> = [
+    // init
+    () => B,
+    // completion
+    (x: B) => B,
+    // accumulation
+    (acc: B, x: A) => B
+];
 
 // A concrete example:
-const push: Reducer<any[], any> = [
+const push: Reducer<any, any[]> = [
     // init
     () => [],
     // completion (nothing to do in this case)
     (acc) => acc,
-    // step
+    // accumulation
     (acc, x) => (acc.push(x), acc)
 ];
 ```
 
-`partition`, `partitionBy`, `streamSort`, `streamShuffle` are (examples
-of) transducers making use of their 1-arity completing function.
-
 #### Reduced
 
+Simple type wrapper to mark & identify a reducer's early termination. Does not
+modify wrapped value by injecting magic properties.
+
 ```ts
 import type { IDeref } from "@thi.ng/api";
 
@@ -750,9 +724,8 @@ class Reduced<T> implements IDeref<T> {
 }
 ```
 
-Simple type wrapper to identify early termination of a reducer. Does not
-modify wrapped value by injecting magic properties. Instances can be
-created via `reduced(x)` and handled via these helper functions:
+Instances can be created via `reduced(x)` and handled via these helper
+functions:
 
 - `reduced(x: any): any`
 - `isReduced(x: any): boolean`
@@ -761,18 +734,18 @@ created via `reduced(x)` and handled via these helper functions:
 
 #### IReducible
 
-By default `reduce()` consumes inputs via the standard ES6 `Iterable`
-interface, i.e. using a `for..of..` loop, but uses optimized routes
-for some types: Array-like inputs are consumed via a traditional
-`for`-loop and custom optimized iterations can be provided via
-implementations of the `IReducible` interface in the source collection
-type. Examples can be found here:
+By default `reduce()` consumes inputs via the standard ES6 `Iterable` interface,
+i.e. using a `for..of..` loop, but the function also supports optimized routes
+for some types: Array-like inputs are consumed via a traditional `for`-loop and
+custom optimized iterations can be provided via implementations of the
+`IReducible` interface in the source collection type. Examples can be found
+here:
 
 - [DCons](https://github.com/thi-ng/umbrella/tree/develop/packages/dcons/src/index.ts#L156)
 - [SortedMap](https://github.com/thi-ng/umbrella/tree/develop/packages/associative/src/sorted-map.ts#L276)
 
-**Note:** The `IReducible` interface is only used by `reduce()`,
-`transduce()` and `run()`.
+**Note:** The `IReducible` interface is only used by `reduce()`, `transduce()`
+and `run()`.
 
 #### Transducer
 
@@ -780,20 +753,20 @@ From Rich Hickey's original definition:
 
 > A transducer is a transformation from one reducing function to another
 
-As shown in the examples above, transducers can be dynamically composed
-(using `comp()`) to form arbitrary data transformation pipelines without
-causing large overheads for intermediate collections.
+As shown in the examples above, transducers can be dynamically composed (using
+`comp()`) to form arbitrary data transformation pipelines without causing large
+overheads for intermediate collections.
 
 ```ts
-type Transducer<A, B> = (rfn: Reducer<any, B>) => Reducer<any, A>;
+type Transducer<A, B> = (rfn: Reducer<B, any>) => Reducer<A, any>;
 
-// concrete example of stateless transducer (expanded for clarity)
+// concrete example of a stateless transducer (expanded for clarity)
 function map<A, B>(fn: (x: A) => B): Transducer<A, B> {
-    return (rfn: Reducer<any, B>) => {
-        return [
-            () => rfn[0](),
-            (acc) => rfn[1](acc),
-            (acc, x: A) => rfn[2](acc, fn(x))
+    return ([init, complete, reduce]: Reducer<B, any>) => {
+        return <Reducer<A, any>>[
+            init,
+            complete,
+            (acc, x: A) => reduce(acc, fn(x))
         ];
     };
 }
@@ -801,14 +774,14 @@ function map<A, B>(fn: (x: A) => B): Transducer<A, B> {
 // stateful transducer
 // removes successive value repetitions
 function dedupe<T>(): Transducer<T, T> {
-    return (rfn: Reducer<any, T>) => {
+    return ([init, complete, reduce]: Reducer<T, any>) => {
         // state initialization
         let prev = {};
-        return [
-            () => rfn[0](),
-            (acc) => rfn[1](acc),
+        return <Reducer<T, any>>[
+            init,
+            complete,
             (acc, x) => {
-                acc = prev === x ? acc : rfn[2](acc, x);
+                if (prev !== x) acc = reduce(acc, x);
                 prev = x;
                 return acc;
             }
@@ -819,10 +792,10 @@ function dedupe<T>(): Transducer<T, T> {
 
 #### IXform interface
 
-Interface for types able to provide some internal functionality (or
-derive some related transformation) as `Transducer`. Implementations of
-this interface can be directly passed to all functions in this package
-where a `Transducer` arg is expected.
+Interface for types able to provide some internal functionality (or derive some
+related transformation) as `Transducer`. Implementations of this interface can
+be directly passed to all functions in this package where a `Transducer` arg is
+expected.
 
 ```ts
 import { map, push, range, transduce, type IXform } from "@thi.ng/transducers";
@@ -856,9 +829,9 @@ transduce(
 
 `comp(f1, f2, ...)`
 
-Returns new transducer composed from given transducers. Data flow is
-from left to right. Offers fast paths for up to 10 args. If more are
-given, composition is done dynamically via for loop.
+Returns new transducer composed from given transducers. Data flow is from left
+to right. Offers fast paths for up to 10 args. If more are given, composition is
+done dynamically via for loop.
 
 #### compR
 
@@ -870,17 +843,16 @@ Helper function to compose reducers.
 
 `iterator<A, B>(tx: Transducer<A, B>, xs: Iterable<A>): IterableIterator<B>`
 
-Similar to `transduce()`, but emits results as ES6 iterator (and hence
-doesn't use a reduction function).
+Similar to `transduce()`, but emits results as ES6 iterator (and hence doesn't
+use a reduction function).
 
 #### reduce
 
 `reduce<A, B>(rfn: Reducer<A, B>, acc?: A, xs: Iterable<B>): A`
 
-Reduces `xs` using given reducer and optional initial
-accumulator/result. If `xs` implements the `IReducible` interface,
-delegates to that implementation. Likewise, uses a fast route if `xs` is
-an `ArrayLike` type.
+Reduces `xs` using given reducer and optional initial accumulator/result. If
+`xs` implements the `IReducible` interface, delegates to that implementation.
+Likewise, uses a fast route if `xs` is an `ArrayLike` type.
 
 #### reduceRight
 
@@ -893,8 +865,8 @@ into right-to-left order.
 
 `transduce<A, B, C>(tx: Transducer<A, B>, rfn: Reducer<C, B>, acc?: C, xs: Iterable<A>): C`
 
-Transforms iterable using given transducer and combines results with
-given reducer and optional initial accumulator/result.
+Transforms iterable using given transducer and combines results with given
+reducer and optional initial accumulator/result.
 
 #### transduceRight
 
@@ -907,11 +879,10 @@ them into right-to-left order.
 
 `run<A, B>(tx: Transducer<A, B>, fx: (x: B) => void, xs: Iterable<A>)`
 
-Transforms iterable with given transducer and optional side effect
-without any reduction step. If `fx` is given it will be called with
-every value produced by the transducer. If `fx` is _not_ given, the
-transducer is assumed to include at least one `sideEffect()` step
-itself. Returns nothing.
+Transforms iterable with given transducer and optional side effect without any
+reduction step. If `fx` is given it will be called with every value produced by
+the transducer. If `fx` is _not_ given, the transducer is assumed to include at
+least one `sideEffect()` step itself. Returns nothing.
 
 #### consume
 
@@ -937,9 +908,9 @@ consume(repeatedly2d((x, y) => console.log("output:", [x, y]), 2, 3));
 
 ### Transducers
 
-All of the following functions can be used and composed as transducers.
-With a few exceptions, most also accept an input iterable and then
-directly yield a transforming iterator, e.g.
+All of the following functions can be used and composed as transducers. With a
+few exceptions, most also accept an input iterable and then directly yield a
+transforming iterator, e.g.
 
 ```ts
 import { map, push, range, transduce } from "@thi.ng/transducers";
@@ -1062,9 +1033,9 @@ transduce(map((x) => x*10), push(), range(4))
 
 ### Reducers
 
-As with transducer functions, reducer functions can also given an
-optional input iterable. If done so, the function will consume the input
-and return a reduced result (as if it would be called via `reduce()`).
+As with transducer functions, reducer functions can also given an optional input
+iterable. If done so, the function will consume the input and return a reduced
+result (as if it would be called via `reduce()`).
 
 - [add](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers/src/add.ts)
 - [assocMap](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers/src/assoc-map.ts)

package/api.d.ts

@@ -1,6 +1,6 @@
 import type { Comparator, Fn, Fn0, IObjectOf } from "@thi.ng/api";
 import type { Reduced } from "./reduced.js";
-export type Transducer<A, B> = (rfn: Reducer<any, B>) => Reducer<any, A>;
+export type Transducer<A, B> = (rfn: Reducer<B, any>) => Reducer<A, any>;
 /**
  * A transducer or a custom type with a {@link IXform} implementation.
  */
@@ -9,28 +9,27 @@ export type TxLike<A, B> = Transducer<A, B> | IXform<A, B>;
  * Custom version of {@link TxLike} for use with {@link multiplex} and
  * {@link multiplexObj}.
  */
-export type MultiplexTxLike<T, A> = TxLike<T, A> | [TxLike<T, A>, boolean];
-export type ReductionFn<A, B> = (acc: A, x: B) => A | Reduced<A>;
+export type MultiplexTxLike<A, B> = TxLike<A, B> | [TxLike<A, B>, boolean];
+/**
+ * Function which combines a new value of type `A` with accumulator of type `B`.
+ * If the reduction should terminate early, the function should wrap the result
+ * via {@link reduced}.
+ */
+export type ReductionFn<A, B> = (acc: B, x: A) => B | Reduced<B>;
 /**
  * A 3-tuple of functions defining the different stages of a reduction process.
+ *
+ * @remarks
+ * The items in order:
+ *
+ * 1. Initialization function used to produce an initial default result (only
+ *    used if no such initial result was given by the user)
+ * 2. Completion function to post-process an already reduced result (for most
+ *    reducers this is merely the identity function). Also see {@link reducer}.
+ * 3. Accumulation function, merging a new input value with the currently
+ *    existing (partially) reduced result.
  */
-export interface Reducer<A, B> extends Array<any> {
-    /**
-     * Initialization function to produce a default initial result (only used if
-     * no such initial result was given by the user)
-     */
-    [0]: Fn0<A>;
-    /**
-     * Completion function to post-process an already reduced result (for most
-     * reducers this is merely the identity function). Also see {@link reducer}.
-     */
-    [1]: Fn<A, A>;
-    /**
-     * Accumulation function, merging a new input value with the currently
-     * existing (partially) reduced result.
-     */
-    [2]: ReductionFn<A, B>;
-}
+export type Reducer<A, B> = [Fn0<B>, Fn<B, B>, ReductionFn<A, B>];
 /**
  * Interface for types able to provide some internal functionality (or
  * derive some related transformation) as {@link Transducer}.
@@ -92,7 +91,7 @@ export interface IReducible<A, B> {
      * @param rfn
      * @param acc
      */
-    $reduce(rfn: ReductionFn<A, B>, acc: A): A | Reduced<A>;
+    $reduce(rfn: ReductionFn<A, B>, acc: B | Reduced<B>): B | Reduced<B>;
 }
 export type TransformFn = (x: any) => any;
 export type TransformSubSpec = IObjectOf<TransformSpec | TransformFn>;
@@ -114,6 +113,6 @@ export interface SortOpts<A, B> {
 }
 export interface GroupByOpts<SRC, KEY, GROUP> {
     key: Fn<SRC, KEY>;
-    group: Reducer<GROUP, SRC>;
+    group: Reducer<SRC, GROUP>;
 }
 //# sourceMappingURL=api.d.ts.map

package/assoc-map.d.ts

@@ -4,6 +4,6 @@ import type { Reducer } from "./api.js";
  * Reducer accepting key-value pairs / tuples and transforming / adding
  * them to an ES6 Map.
  */
-export declare function assocMap<A, B>(): Reducer<Map<A, B>, Pair<A, B>>;
+export declare function assocMap<A, B>(): Reducer<Pair<A, B>, Map<A, B>>;
 export declare function assocMap<A, B>(xs: Iterable<Pair<A, B>>): Map<A, B>;
 //# sourceMappingURL=assoc-map.d.ts.map

package/assoc-obj.d.ts

@@ -4,6 +4,6 @@ import type { Reducer } from "./api.js";
  * Reducer accepting key-value pairs / tuples and updating / adding them
  * to an object.
  */
-export declare function assocObj<T>(): Reducer<IObjectOf<T>, Pair<PropertyKey, T>>;
+export declare function assocObj<T>(): Reducer<Pair<PropertyKey, T>, IObjectOf<T>>;
 export declare function assocObj<T>(xs: Iterable<Pair<PropertyKey, T>>): IObjectOf<T>;
 //# sourceMappingURL=assoc-obj.d.ts.map

package/auto-obj.d.ts

@@ -14,6 +14,6 @@ import type { Reducer } from "./api.js";
  *
  * @param prefix - shared prefix
  */
-export declare function autoObj<T>(prefix: string): Reducer<IObjectOf<T>, T>;
+export declare function autoObj<T>(prefix: string): Reducer<T, IObjectOf<T>>;
 export declare function autoObj<T>(prefix: string, xs: Iterable<T>): IObjectOf<T>;
 //# sourceMappingURL=auto-obj.d.ts.map

package/compr.d.ts

@@ -25,5 +25,5 @@ import type { Reducer, ReductionFn } from "./api.js";
  * @param rfn -
  * @param fn -
  */
-export declare const compR: <A, B, C>(rfn: Reducer<A, B>, fn: ReductionFn<A, C>) => Reducer<A, C>;
+export declare const compR: <A, B, C>(rfn: Reducer<B, C>, fn: ReductionFn<A, C>) => Reducer<A, C>;
 //# sourceMappingURL=compr.d.ts.map

package/conj.d.ts

@@ -2,6 +2,6 @@ import type { Reducer } from "./api.js";
 /**
  * Reducer. Like {@link push}, but for ES6 Sets.
  */
-export declare function conj<T>(): Reducer<Set<T>, T>;
+export declare function conj<T>(): Reducer<T, Set<T>>;
 export declare function conj<T>(xs: Iterable<T>): Set<T>;
 //# sourceMappingURL=conj.d.ts.map

package/count.d.ts

@@ -6,7 +6,7 @@ import type { Reducer } from "./api.js";
  * @param offset -
  * @param step -
  */
-export declare function count(offset?: number, step?: number): Reducer<number, any>;
+export declare function count(offset?: number, step?: number): Reducer<any, number>;
 export declare function count(xs: Iterable<any>): number;
 export declare function count(offset: number, xs: Iterable<any>): number;
 export declare function count(offset: number, step: number, xs: Iterable<any>): number;

package/count.js

@@ -4,8 +4,7 @@ function count(...args) {
   if (res !== void 0) {
     return res;
   }
-  let offset = args[0] || 0;
-  let step = args[1] || 1;
+  const [offset = 0, step = 1] = args;
   return reducer(
     () => offset,
     (acc, _) => acc + step

package/fill.d.ts

@@ -7,7 +7,7 @@ import type { Reducer } from "./api.js";
  *
  * @param start -
  */
-export declare function fill<T>(start?: number): Reducer<T[], T>;
+export declare function fill<T>(start?: number): Reducer<T, T[]>;
 export declare function fill<T>(xs: Iterable<T>): T[];
 export declare function fill<T>(start: number, xs: Iterable<T>): T[];
 /**
@@ -15,7 +15,7 @@ export declare function fill<T>(start: number, xs: Iterable<T>): T[];
  *
  * @param start -
  */
-export declare function fillN(start?: number): Reducer<NumericArray, number>;
+export declare function fillN(start?: number): Reducer<number, NumericArray>;
 export declare function fillN(xs: Iterable<number>): NumericArray;
 export declare function fillN(start: number, xs: Iterable<number>): NumericArray;
 //# sourceMappingURL=fill.d.ts.map

package/frequencies.d.ts

@@ -1,7 +1,7 @@
 import type { Fn } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
-export declare function frequencies<A>(): Reducer<Map<A, number>, A>;
+export declare function frequencies<A>(): Reducer<A, Map<A, number>>;
 export declare function frequencies<A>(xs: Iterable<A>): Map<A, number>;
-export declare function frequencies<A, B>(key: Fn<A, B>): Reducer<Map<B, number>, A>;
+export declare function frequencies<A, B>(key: Fn<A, B>): Reducer<A, Map<B, number>>;
 export declare function frequencies<A, B>(key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=frequencies.d.ts.map

package/group-binary.d.ts

@@ -5,7 +5,7 @@ import type { Reducer } from "./api.js";
  * data structures. Any value can be indexed, as long as a numeric
  * representation (key) can be obtained. This numeric key is produced by the
  * supplied `key` function. IMPORTANT: the returned values MUST be unsigned and
- * less than the provided bit length (i.e. `0 .. (2^bits) - 1` range).
+ * less than the provided bit length (i.e. in the `[0,2**bits)` interval).
  *
  * By default the tree is constructed using plain objects for branches, with
  * left branches stored as "l" and right ones as "r". The original values are
@@ -40,8 +40,8 @@ import type { Reducer } from "./api.js";
  * import { groupBinary, identity, push, reduce } from "@thi.ng/transducers";
  *
  * tree = reduce(
- *   groupBinary(4, identity, ()=>[], push(), 0, 1),
- *   [1,2,3,4,5,6,7]
+ *   groupBinary(4, identity, () => [], push(), 0, 1),
+ *   [1, 2, 3, 4, 5, 6, 7]
  * )
  *
  * tree[0][1][0][1] // 0101 == 5 in binary
@@ -78,5 +78,5 @@ import type { Reducer } from "./api.js";
  * @param left - key for storing left branches (e.g. `0` for arrays)
  * @param right - key for storing right branches (e.g. `1` for arrays)
  */
-export declare const groupBinary: <T>(bits: number, key: Fn<T, number>, branch?: Fn0<IObjectOf<T[]>>, leaf?: Reducer<any, T>, left?: PropertyKey, right?: PropertyKey) => Reducer<any, T>;
+export declare const groupBinary: <T>(bits: number, key: Fn<T, number>, branch?: Fn0<IObjectOf<T[]>>, leaf?: Reducer<T, any>, left?: PropertyKey, right?: PropertyKey) => Reducer<T, any>;
 //# sourceMappingURL=group-binary.d.ts.map

package/group-by-map.d.ts

@@ -1,5 +1,5 @@
 import type { GroupByOpts, Reducer } from "./api.js";
-export declare function groupByMap<SRC, KEY, GROUP>(opts?: Partial<GroupByOpts<SRC, KEY, GROUP>>): Reducer<Map<KEY, GROUP>, SRC>;
+export declare function groupByMap<SRC, KEY, GROUP>(opts?: Partial<GroupByOpts<SRC, KEY, GROUP>>): Reducer<SRC, Map<KEY, GROUP>>;
 export declare function groupByMap<SRC, GROUP>(xs: Iterable<SRC>): Map<SRC, GROUP>;
 export declare function groupByMap<SRC, KEY, GROUP>(opts: Partial<GroupByOpts<SRC, KEY, GROUP>>, xs: Iterable<SRC>): Map<KEY, GROUP>;
 //# sourceMappingURL=group-by-map.d.ts.map

package/group-by-map.js

@@ -2,9 +2,8 @@ import { __groupByOpts } from "./internal/group-opts.js";
 import { $$reduce } from "./reduce.js";
 function groupByMap(...args) {
   const res = $$reduce(groupByMap, args);
-  if (res !== void 0) {
+  if (res !== void 0)
     return res;
-  }
   const opts = __groupByOpts(args[0]);
   const [init, complete, reduce] = opts.group;
   return [

package/group-by-obj.d.ts

@@ -1,6 +1,6 @@
 import type { IObjectOf } from "@thi.ng/api";
 import type { GroupByOpts, Reducer } from "./api.js";
-export declare function groupByObj<SRC, GROUP>(opts?: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>): Reducer<IObjectOf<GROUP>, SRC>;
+export declare function groupByObj<SRC, GROUP>(opts?: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>): Reducer<SRC, IObjectOf<GROUP>>;
 export declare function groupByObj<SRC>(xs: Iterable<SRC>): IObjectOf<SRC[]>;
 export declare function groupByObj<SRC, GROUP>(opts: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>, xs: Iterable<SRC>): IObjectOf<GROUP>;
 //# sourceMappingURL=group-by-obj.d.ts.map

package/group-by-obj.js

@@ -2,9 +2,8 @@ import { __groupByOpts } from "./internal/group-opts.js";
 import { $$reduce } from "./reduce.js";
 function groupByObj(...args) {
   const res = $$reduce(groupByObj, args);
-  if (res) {
+  if (res)
     return res;
-  }
   const opts = __groupByOpts(args[0]);
   const [_init, complete, _reduce] = opts.group;
   return [

package/internal/drain.d.ts

@@ -10,5 +10,5 @@ import type { ReductionFn } from "../api.js";
  *
  * @internal
  */
-export declare const __drain: <T>(buf: T[], complete: Fn<any, any>, reduce: ReductionFn<any, T>) => (acc: T[]) => any;
+export declare const __drain: <T>(buf: T[], complete: Fn<any, any>, reduce: ReductionFn<T, any>) => (acc: T[]) => any;
 //# sourceMappingURL=drain.d.ts.map

package/juxtr.d.ts

@@ -18,8 +18,8 @@ import type { Reducer } from "./api.js";
  * // [ 10, [ 0, 1, 3, 6, 10 ], '1-2-3-4' ]
  * ```
  */
-export declare function juxtR<A1, B>(r1: Reducer<A1, B>): Reducer<[A1], B>;
-export declare function juxtR<A1, A2, B>(r1: Reducer<A1, B>, r2: Reducer<A2, B>): Reducer<[A1, A2], B>;
-export declare function juxtR<A1, A2, A3, B>(r1: Reducer<A1, B>, r2: Reducer<A2, B>, r3: Reducer<A3, B>): Reducer<[A1, A2, A3], B>;
-export declare function juxtR<A1, A2, A3, B>(r1: Reducer<A1, B>, r2: Reducer<A2, B>, r3: Reducer<A3, B>, ...rs: Reducer<any, B>[]): Reducer<any[], B>;
+export declare function juxtR<A, B1>(r1: Reducer<A, B1>): Reducer<A, [B1]>;
+export declare function juxtR<A, B1, B2>(r1: Reducer<A, B1>, r2: Reducer<A, B2>): Reducer<A, [B1, B2]>;
+export declare function juxtR<A, B1, B2, B3>(r1: Reducer<A, B1>, r2: Reducer<A, B2>, r3: Reducer<A, B3>): Reducer<A, [B1, B2, B3]>;
+export declare function juxtR<A, B1, B2, B3>(r1: Reducer<A, B1>, r2: Reducer<A, B2>, r3: Reducer<A, B3>, ...rs: Reducer<A, any>[]): Reducer<A, any[]>;
 //# sourceMappingURL=juxtr.d.ts.map

package/map.d.ts

@@ -18,7 +18,7 @@ export declare function map<A, B>(fn: Fn<A, B>): Transducer<A, B>;
 export declare function map<A, B>(fn: Fn<A, B>, src: Iterable<A>): IterableIterator<B>;
 /**
  * Convenience wrapper for {@link map} to transform an iterable with given `fn`
- * and immediatedly collect results into an array.
+ * and immediately collect results into an array.
  */
 export declare const mapA: <A, B>(fn: Fn<A, B>, src: Iterable<A>) => B[];
 //# sourceMappingURL=map.d.ts.map

package/mapcat.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "@thi.ng/api";
+import type { Fn, Nullable } from "@thi.ng/api";
 import type { Transducer } from "./api.js";
 /**
  * Transducer. Similar to {@link map}, but expects the given mapping function
@@ -19,6 +19,6 @@ import type { Transducer } from "./api.js";
  *
  * @param fn - mapping function
  */
-export declare function mapcat<A, B>(fn: Fn<A, Iterable<B> | null | undefined>): Transducer<A, B>;
-export declare function mapcat<A, B>(fn: Fn<A, Iterable<B> | null | undefined>, src: Iterable<A>): IterableIterator<B>;
+export declare function mapcat<A, B>(fn: Fn<A, Nullable<Iterable<B>>>): Transducer<A, B>;
+export declare function mapcat<A, B>(fn: Fn<A, Nullable<Iterable<B>>>, src: Iterable<A>): IterableIterator<B>;
 //# sourceMappingURL=mapcat.d.ts.map

package/min-max.d.ts

@@ -2,5 +2,5 @@
  * Returns a reducer which computes both the min and max values of given inputs.
  * If the input source is empty the final result will be `[-∞,∞]`.
  */
-export declare const minMax: () => import("./api.js").Reducer<[number, number], number>;
+export declare const minMax: () => import("./api.js").Reducer<number, [number, number]>;
 //# sourceMappingURL=min-max.d.ts.map

package/moving-median.js

@@ -5,9 +5,8 @@ import { map } from "./map.js";
 import { partition } from "./partition.js";
 function movingMedian(...args) {
   const iter = __iter(movingMedian, args);
-  if (iter) {
+  if (iter)
     return iter;
-  }
   const { key, compare } = __sortOpts(args[1]);
   const n = args[0];
   const m = n >> 1;

package/multiplex-obj.d.ts

@@ -24,7 +24,7 @@ import type { MultiplexTxLike, Reducer, Transducer } from "./api.js";
  * @param xforms - object of transducers
  * @param rfn -
  */
-export declare function multiplexObj<A, B>(xforms: IObjectOf<MultiplexTxLike<A, any>>, rfn?: Reducer<B, [PropertyKey, any]>): Transducer<A, B>;
+export declare function multiplexObj<A, B>(xforms: IObjectOf<MultiplexTxLike<A, any>>, rfn?: Reducer<[PropertyKey, any], B>): Transducer<A, B>;
 export declare function multiplexObj<A, B>(xforms: IObjectOf<MultiplexTxLike<A, any>>, src: Iterable<A>): IterableIterator<B>;
-export declare function multiplexObj<A, B>(xforms: IObjectOf<MultiplexTxLike<A, any>>, rfn: Reducer<B, [PropertyKey, any]>, src: Iterable<A>): IterableIterator<B>;
+export declare function multiplexObj<A, B>(xforms: IObjectOf<MultiplexTxLike<A, any>>, rfn: Reducer<[PropertyKey, any], B>, src: Iterable<A>): IterableIterator<B>;
 //# sourceMappingURL=multiplex-obj.d.ts.map

package/noop.js

@@ -1,4 +1,5 @@
-const noop = () => (rfn) => rfn;
+import { identity } from "@thi.ng/api/fn";
+const noop = () => identity;
 export {
   noop
 };

package/norm-count.d.ts

@@ -21,6 +21,6 @@ import type { Reducer } from "./api.js";
  *
  * @param norm -
  */
-export declare function normCount(norm: number): Reducer<number, any>;
+export declare function normCount(norm: number): Reducer<any, number>;
 export declare function normCount(norm: number, xs: Iterable<any>): number;
 //# sourceMappingURL=norm-count.d.ts.map

package/norm-count.js

@@ -1,9 +1,8 @@
 import { $$reduce } from "./reduce.js";
 function normCount(...args) {
   const res = $$reduce(normCount, args);
-  if (res !== void 0) {
+  if (res !== void 0)
     return res;
-  }
   const norm = args[0];
   return [() => 0, (acc) => acc / norm, (acc) => acc + 1];
 }

package/norm-frequencies-auto.d.ts

@@ -18,8 +18,8 @@ import type { Reducer } from "./api.js";
  * // Map(3) { 'a' => 0.5, 'b' => 0.25, 'c' => 0.25 }
  * ```
  */
-export declare function normFrequenciesAuto<A>(): Reducer<Map<A, number>, A>;
+export declare function normFrequenciesAuto<A>(): Reducer<A, Map<A, number>>;
 export declare function normFrequenciesAuto<A>(xs: Iterable<A>): Map<A, number>;
-export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>): Reducer<Map<B, number>, A>;
+export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>): Reducer<A, Map<B, number>>;
 export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=norm-frequencies-auto.d.ts.map

package/norm-frequencies-auto.js

@@ -2,9 +2,8 @@ import { frequencies } from "./frequencies.js";
 import { $$reduce } from "./reduce.js";
 function normFrequenciesAuto(...args) {
   const res = $$reduce(normFrequenciesAuto, args);
-  if (res !== void 0) {
+  if (res !== void 0)
     return res;
-  }
   const [init, complete, reduce] = frequencies(...args);
   let norm = 0;
   return [

package/norm-frequencies.d.ts

@@ -19,8 +19,8 @@ import type { Reducer } from "./api.js";
  *
  * @param norm -
  */
-export declare function normFrequencies<A>(norm: number): Reducer<Map<A, number>, A>;
+export declare function normFrequencies<A>(norm: number): Reducer<A, Map<A, number>>;
 export declare function normFrequencies<A>(norm: number, xs: Iterable<A>): Map<A, number>;
-export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>): Reducer<Map<B, number>, A>;
+export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>): Reducer<A, Map<B, number>>;
 export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=norm-frequencies.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/transducers",
-  "version": "8.9.18",
+  "version": "9.0.0",
   "description": "Lightweight transducer implementations for ES6 / TypeScript",
   "type": "module",
   "module": "./index.js",
@@ -40,14 +40,14 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.31",
-    "@thi.ng/arrays": "^2.9.1",
-    "@thi.ng/checks": "^3.5.5",
-    "@thi.ng/compare": "^2.3.0",
-    "@thi.ng/compose": "^2.1.71",
-    "@thi.ng/errors": "^2.5.2",
-    "@thi.ng/math": "^5.10.8",
-    "@thi.ng/random": "^3.7.1"
+    "@thi.ng/api": "^8.10.0",
+    "@thi.ng/arrays": "^2.9.2",
+    "@thi.ng/checks": "^3.6.0",
+    "@thi.ng/compare": "^2.3.1",
+    "@thi.ng/compose": "^3.0.0",
+    "@thi.ng/errors": "^2.5.3",
+    "@thi.ng/math": "^5.10.9",
+    "@thi.ng/random": "^3.7.2"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.43.0",
@@ -59,7 +59,6 @@
   "keywords": [
     "2d",
     "3d",
-    "nd",
     "array",
     "clojure",
     "composition",
@@ -76,6 +75,7 @@
     "interleave",
     "interpolation",
     "iterator",
+    "nd",
     "partition",
     "permutation",
     "pipeline",
@@ -86,8 +86,8 @@
     "set",
     "sliding-window",
     "stream",
-    "time",
     "throttle",
+    "time",
     "transducer",
     "transformation",
     "tween",
@@ -564,6 +564,7 @@
     }
   },
   "thi.ng": {
+    "alias": "tx",
     "blog": [
       {
         "title": "HOFs, Transducers, Reducers",
@@ -589,5 +590,5 @@
     ],
     "year": 2016
   },
-  "gitHead": "ce5ae2a322d50a7ce8ecccbd94fa55c496ba04fd\n"
+  "gitHead": "85ac4bd4d6d89f8e3689e2863d5bea0cecdb371c\n"
 }

package/push-copy.d.ts

@@ -1,3 +1,3 @@
 import type { Reducer } from "./api.js";
-export declare const pushCopy: <T>() => Reducer<T[], T>;
+export declare const pushCopy: <T>() => Reducer<T, T[]>;
 //# sourceMappingURL=push-copy.d.ts.map

package/push-sort.d.ts

@@ -7,6 +7,6 @@ import type { Reducer } from "./api.js";
  *
  * @param cmp -
  */
-export declare function pushSort<T>(cmp?: Comparator<T>): Reducer<T[], T>;
-export declare function pushSort<T>(cmp: Comparator<T>, xs: Iterable<T>): T[];
+export declare function pushSort<T>(cmp?: Comparator<T>): Reducer<T, T[]>;
+export declare function pushSort<T>(cmp: Comparator<T> | undefined, xs: Iterable<T>): T[];
 //# sourceMappingURL=push-sort.d.ts.map

package/push.d.ts

@@ -1,4 +1,4 @@
 import type { Reducer } from "./api.js";
-export declare function push<T>(): Reducer<T[], T>;
+export declare function push<T>(): Reducer<T, T[]>;
 export declare function push<T>(xs: Iterable<T>): T[];
 //# sourceMappingURL=push.d.ts.map

package/range.d.ts

@@ -9,7 +9,7 @@ export declare function range(from: number, to: number, step: number): Range;
  * and {@link IReducible} interfaces, the latter is used to accelerate use with
  * {@link reduce}.
  */
-export declare class Range implements Iterable<number>, IReducible<any, number> {
+export declare class Range implements Iterable<number>, IReducible<number, any> {
     protected from: number;
     protected to: number;
     protected step: number;
@@ -17,6 +17,6 @@ export declare class Range implements Iterable<number>, IReducible<any, number>
     constructor(from: number, to: number);
     constructor(from: number, to: number, step: number);
     [Symbol.iterator](): Generator<number, void, unknown>;
-    $reduce<T>(rfn: ReductionFn<T, number>, acc: T): T | Reduced<T>;
+    $reduce<T>(rfn: ReductionFn<number, T>, acc: T | Reduced<T>): T | Reduced<T>;
 }
 //# sourceMappingURL=range.d.ts.map

package/reduce.d.ts

@@ -1,11 +1,11 @@
 import type { Fn0, FnAny } from "@thi.ng/api";
 import type { IReducible, Reducer, ReductionFn } from "./api.js";
-export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: Iterable<B>): A;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: A, xs: Iterable<B>): A;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: IReducible<A, B>): A;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: A, xs: IReducible<A, B>): A;
-export declare function reduceRight<A, B>(rfn: Reducer<A, B>, xs: ArrayLike<B>): A;
-export declare function reduceRight<A, B>(rfn: Reducer<A, B>, acc: A, xs: ArrayLike<B>): A;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: Iterable<A>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: B, xs: Iterable<A>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: IReducible<A, B>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: A, xs: IReducible<A, B>): B;
+export declare function reduceRight<A, B>(rfn: Reducer<A, B>, xs: ArrayLike<A>): B;
+export declare function reduceRight<A, B>(rfn: Reducer<A, B>, acc: B, xs: ArrayLike<A>): B;
 /**
  * Convenience helper for building a full {@link Reducer} using the identity
  * function (i.e. `(x) => x`) as completion step (true for 90% of all
@@ -14,6 +14,6 @@ export declare function reduceRight<A, B>(rfn: Reducer<A, B>, acc: A, xs: ArrayL
  * @param init - init step of reducer
  * @param rfn - reduction step of reducer
  */
-export declare const reducer: <A, B>(init: Fn0<A>, rfn: ReductionFn<A, B>) => Reducer<A, B>;
+export declare const reducer: <A, B>(init: Fn0<B>, rfn: ReductionFn<A, B>) => Reducer<A, B>;
 export declare const $$reduce: (rfn: FnAny<Reducer<any, any>>, args: any[]) => any;
 //# sourceMappingURL=reduce.d.ts.map

package/reduce.js

@@ -1,3 +1,4 @@
+import { identity } from "@thi.ng/api/fn";
 import { implementsFunction } from "@thi.ng/checks/implements-function";
 import { isArrayLike } from "@thi.ng/checks/is-arraylike";
 import { isIterable } from "@thi.ng/checks/is-iterable";
@@ -19,10 +20,7 @@ function reduce(...args) {
   );
 }
 function reduceRight(...args) {
-  const rfn = args[0];
-  const init = rfn[0];
-  const complete = rfn[1];
-  const reduce2 = rfn[2];
+  const [init, complete, reduce2] = args[0];
   args = parseArgs(args);
   let acc = args[0] == null ? init() : args[0];
   const xs = args[1];
@@ -55,7 +53,7 @@ const reduceIterable = (rfn, acc, xs) => {
   }
   return acc;
 };
-const reducer = (init, rfn) => [init, (acc) => acc, rfn];
+const reducer = (init, rfn) => [init, identity, rfn];
 const $$reduce = (rfn, args) => {
   const n = args.length - 1;
   return isIterable(args[n]) ? args.length > 1 ? reduce(rfn.apply(null, args.slice(0, n)), args[n]) : reduce(rfn(), args[0]) : void 0;

package/reduced.d.ts

@@ -4,8 +4,8 @@ export declare class Reduced<T> implements IDeref<T> {
     constructor(val: T);
     deref(): T;
 }
-export declare const reduced: (x: any) => any;
+export declare const reduced: <T>(x: T) => Reduced<T>;
 export declare const isReduced: <T>(x: any) => x is Reduced<T>;
-export declare const ensureReduced: (x: any) => Reduced<any>;
-export declare const unreduced: (x: any) => any;
+export declare const ensureReduced: <T>(x: T) => (T & Reduced<any>) | Reduced<T>;
+export declare const unreduced: <T>(x: T | Reduced<T>) => T;
 //# sourceMappingURL=reduced.d.ts.map

package/reductions.d.ts

@@ -1,4 +1,4 @@
 import type { Reducer } from "./api.js";
-export declare function reductions<A, B>(rfn: Reducer<A, B>): Reducer<A[], B>;
-export declare function reductions<A, B>(rfn: Reducer<A, B>, xs: Iterable<B>): A[];
+export declare function reductions<A, B>(rfn: Reducer<A, B>): Reducer<A, B[]>;
+export declare function reductions<A, B>(rfn: Reducer<A, B>, xs: Iterable<A>): B[];
 //# sourceMappingURL=reductions.d.ts.map

package/rename.d.ts

@@ -11,6 +11,6 @@ import type { Reducer, Transducer } from "./api.js";
  * @param kmap
  * @param rfn
  */
-export declare function rename<A, B>(kmap: IObjectOf<PropertyKey | boolean> | Array<PropertyKey>, rfn?: Reducer<B, [PropertyKey, A]>): Transducer<A[], B>;
-export declare function rename<A, B>(kmap: IObjectOf<PropertyKey | boolean> | Array<PropertyKey>, rfn: Reducer<B, [PropertyKey, A]>, src: Iterable<A[]>): IterableIterator<B>;
+export declare function rename<A, B>(kmap: IObjectOf<PropertyKey | boolean> | Array<PropertyKey>, rfn?: Reducer<[PropertyKey, any], B>): Transducer<A[], B>;
+export declare function rename<A, B>(kmap: IObjectOf<PropertyKey | boolean> | Array<PropertyKey>, rfn: Reducer<[PropertyKey, any], B>, src: Iterable<A[]>): IterableIterator<B>;
 //# sourceMappingURL=rename.d.ts.map

package/rename.js

@@ -10,19 +10,21 @@ function rename(...args) {
   if (iter) {
     return iter;
   }
-  let kmap = args[0];
+  let [kmap, reducer] = args;
   if (isArray(kmap)) {
     kmap = kmap.reduce((acc, k, i) => (acc[k] = i, acc), {});
   }
-  if (args[1]) {
+  if (reducer) {
     const ks = Object.keys(kmap);
     return map(
       (y) => transduce(
         comp(
-          map((k) => [k, y[kmap[k]]]),
+          map(
+            (k) => [k, y[kmap[k]]]
+          ),
           filter((x) => x[1] !== void 0)
         ),
-        args[1],
+        reducer,
         ks
       )
     );

package/run.d.ts

@@ -11,7 +11,7 @@ import type { IReducible, TxLike } from "./api.js";
  * @param xs -
  */
 export declare function run<A>(tx: TxLike<A, any>, xs: Iterable<A>): void;
-export declare function run<A>(tx: TxLike<A, any>, xs: IReducible<any, A>): void;
+export declare function run<A>(tx: TxLike<A, any>, xs: IReducible<A, any>): void;
 export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, xs: Iterable<A>): void;
-export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, xs: IReducible<any, A>): void;
+export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, xs: IReducible<A, any>): void;
 //# sourceMappingURL=run.d.ts.map

package/scan.d.ts

@@ -43,6 +43,6 @@ import type { Reducer, Transducer } from "./api.js";
  * @param rfn - reducer used as scan operator
  * @param init -
  */
-export declare function scan<A, B>(rfn: Reducer<B, A>, init?: B): Transducer<A, B>;
-export declare function scan<A, B>(rfn: Reducer<B, A>, init: B, src: Iterable<A>): IterableIterator<B>;
+export declare function scan<A, B>(rfn: Reducer<A, B>, init?: B): Transducer<A, B>;
+export declare function scan<A, B>(rfn: Reducer<A, B>, init: B, src: Iterable<A>): IterableIterator<B>;
 //# sourceMappingURL=scan.d.ts.map

package/some.d.ts

@@ -7,7 +7,7 @@ import type { Reducer } from "./api.js";
  *
  * @param pred -
  */
-export declare function some<T>(pred?: Predicate<T>): Reducer<boolean, T>;
+export declare function some<T>(pred?: Predicate<T>): Reducer<T, boolean>;
 export declare function some<T>(xs: Iterable<T>): boolean;
 export declare function some<T>(pred: Predicate<T>, xs: Iterable<T>): boolean;
 //# sourceMappingURL=some.d.ts.map

package/some.js

@@ -2,9 +2,8 @@ import { $$reduce, reducer } from "./reduce.js";
 import { reduced } from "./reduced.js";
 function some(...args) {
   const res = $$reduce(some, args);
-  if (res !== void 0) {
+  if (res !== void 0)
     return res;
-  }
   const pred = args[0];
   return reducer(
     () => false,

package/step.d.ts

@@ -51,5 +51,5 @@ import type { TxLike } from "./api.js";
  * @param tx -
  * @param unwrap -
  */
-export declare const step: <A, B>(tx: TxLike<A, B>, unwrap?: boolean) => Fn<A, B | B[]>;
+export declare const step: <A, B>(tx: TxLike<A, B>, unwrap?: boolean) => Fn<A, B | B[] | undefined>;
 //# sourceMappingURL=step.d.ts.map

package/step.js

@@ -2,7 +2,7 @@ import { ensureTransducer } from "./ensure.js";
 import { push } from "./push.js";
 import { isReduced } from "./reduced.js";
 const step = (tx, unwrap = true) => {
-  const { 1: complete, 2: reduce } = ensureTransducer(tx)(push());
+  const [_, complete, reduce] = ensureTransducer(tx)(push());
   let done = false;
   return (x) => {
     if (!done) {

package/str.d.ts

@@ -1,4 +1,4 @@
 import type { Reducer } from "./api.js";
-export declare function str(sep?: string): Reducer<string, any>;
+export declare function str(sep?: string): Reducer<any, string>;
 export declare function str(sep: string, xs: Iterable<any>): string;
 //# sourceMappingURL=str.d.ts.map

package/struct.d.ts

@@ -1,10 +1,9 @@
 import type { Fn } from "@thi.ng/api";
 import type { Transducer } from "./api.js";
-export interface StructField extends Array<any> {
-    [0]: string;
-    [1]: number;
-    [2]?: Fn<any[], any>;
-}
+/**
+ * Structfield definition: [name, number-of-inputs, transform?]
+ */
+export type StructField<T> = [string, number, Fn<T[], any>?];
 /**
  * Higher-order transducer to converts linear input into structured
  * objects using given field specs and ordering.
@@ -39,6 +38,6 @@ export interface StructField extends Array<any> {
  *
  * @param fields -
  */
-export declare function struct<T>(fields: StructField[]): Transducer<any, T>;
-export declare function struct<T>(fields: StructField[], src: Iterable<any>): IterableIterator<T>;
+export declare function struct<A, B>(fields: StructField<A>[]): Transducer<A, B>;
+export declare function struct<A, B>(fields: StructField<A>[], src: Iterable<A>): IterableIterator<B>;
 //# sourceMappingURL=struct.d.ts.map

package/struct.js

@@ -2,8 +2,8 @@ import { isIterable } from "@thi.ng/checks/is-iterable";
 import { comp } from "./comp.js";
 import { iterator } from "./iterator.js";
 import { mapKeys } from "./map-keys.js";
-import { partition } from "./partition.js";
 import { partitionOf } from "./partition-of.js";
+import { partition } from "./partition.js";
 import { rename } from "./rename.js";
 function struct(fields, src) {
   return isIterable(src) ? iterator(struct(fields), src) : comp(

package/transduce.d.ts

@@ -1,10 +1,10 @@
 import type { IReducible, Reducer, Transducer, TxLike } from "./api.js";
-export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>): Transducer<Iterable<A>, C>;
-export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, xs: Iterable<A>): C;
-export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, xs: IReducible<C, A>): C;
-export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, acc: C, xs: Iterable<A>): C;
-export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, acc: C, xs: IReducible<C, A>): C;
-export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>): Transducer<ArrayLike<A>, C>;
-export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, xs: ArrayLike<A>): C;
-export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, acc: C, xs: ArrayLike<A>): C;
+export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>): Transducer<Iterable<A>, C>;
+export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>, xs: Iterable<A>): C;
+export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>, xs: IReducible<A, C>): C;
+export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>, acc: C, xs: Iterable<A>): C;
+export declare function transduce<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<C, B>, acc: C, xs: IReducible<A, C>): C;
+export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>): Transducer<ArrayLike<A>, C>;
+export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>, xs: ArrayLike<A>): C;
+export declare function transduceRight<A, B, C>(tx: TxLike<A, B>, rfn: Reducer<B, C>, acc: C, xs: ArrayLike<A>): C;
 //# sourceMappingURL=transduce.d.ts.map