synstate 0.1.1 → 1.0.0

package/src/core/operators/{throttle-time.mts → throttle.mts}

@@ -3,8 +3,9 @@ import { SyncChildObservableClass } from '../class/index.mjs';
 import {
   type KeepInitialValueOperator,
   type Observable,
-  type ThrottleTimeOperatorObservable,
-  type UpdaterSymbol,
+  type ThrottleOperatorObservable,
+  type TimerId,
+  type UpdateToken,
 } from '../types/index.mjs';
 
 /**
@@ -17,68 +18,87 @@ import {
  *
  * @example
  * ```ts
- * //  Timeline (1000ms throttle):
+ * //  Timeline (250ms throttle):
  * //
- * //  Time(ms)  0    100   200   300   ...   1000  1100  1200  ...   2000  2100
- * //  scroll$   e1   e2    e3    e4          e5    e6    e7          e8    e9
- * //  throttled$ e1                          e5                      e8
- * //             |-------1000ms------>       |------1000ms------>    |------1000ms------>
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //               |- 250ms -> |- 250ms ->         |- 250ms ->    |- 250ms ->
+ * //  throttled$   0           3                   9          12           (emitted at start of window)
  * //
  * //  Explanation:
- * //  - throttleTime emits the first value immediately, then ignores subsequent values
- * //    for the specified duration (1000ms)
- * //  - At 0ms: e1 is emitted immediately
- * //  - At 100-300ms: e2, e3, e4 are ignored (within 1000ms window)
- * //  - At 1000ms: e5 is emitted (1000ms has passed since e1)
- * //  - At 1100-1200ms: e6, e7 are ignored
- * //  - At 2000ms: e8 is emitted (1000ms has passed since e5)
+ * //  - throttle emits the FIRST value received, then ignores subsequent values
+ * //    for the specified duration (250ms)
+ * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST
+ * //  - Useful for rate-limiting scroll/resize events
  *
- * const scroll$ = source<number>();
+ * const input$ = source<number>();
  *
- * const throttled$ = scroll$.pipe(throttleTime(200));
+ * const throttled$ = input$.pipe(throttle(250));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * throttled$.subscribe((value) => {
- *   mut_history.push(value);
+ *   valueHistory.push(value);
  * });
  *
- * scroll$.next(1);
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * input$.next(0);
  *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 50);
- * });
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
- * scroll$.next(2);
+ * await sleep(200);
  *
- * scroll$.next(3);
+ * input$.next(2);
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
- * await new Promise((resolve) => {
- *   setTimeout(resolve, 200);
- * });
+ * await sleep(100);
+ *
+ * input$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
  *
- * scroll$.next(4);
+ * input$.next(12);
  *
- * assert.deepStrictEqual(mut_history, [1, 4]);
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);
  * ```
  */
-export const throttleTime = <A,>(
+export const throttle = <A,>(
   milliSeconds: number,
 ): KeepInitialValueOperator<A, A> =>
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   ((parentObservable) =>
-    new ThrottleTimeObservableClass(
+    new ThrottleObservableClass(
       parentObservable,
       milliSeconds,
     )) as KeepInitialValueOperator<A, A>;
 
-class ThrottleTimeObservableClass<A>
+class ThrottleObservableClass<A>
   extends SyncChildObservableClass<A, readonly [A]>
-  implements ThrottleTimeOperatorObservable<A>
+  implements ThrottleOperatorObservable<A>
 {
   readonly #milliSeconds: number;
   #mut_timerId: TimerId | undefined;
@@ -97,20 +117,20 @@ class ThrottleTimeObservableClass<A>
     this.#milliSeconds = milliSeconds;
   }
 
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
+  override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
     const sn = par.getSnapshot();
 
     if (
-      par.updaterSymbol !== updaterSymbol ||
+      par.updateToken !== updateToken ||
       Optional.isNone(sn) ||
       this.#mut_isSkipping
     ) {
       return; // skip update
     }
 
-    this.setNext(sn.value, updaterSymbol);
+    this.setNext(sn.value, updateToken);
 
     this.#mut_isSkipping = true;
 

package/src/core/operators/with-buffered-from.mts

@@ -3,7 +3,7 @@ import { SyncChildObservableClass } from '../class/index.mjs';
 import {
   type KeepInitialValueOperator,
   type Observable,
-  type UpdaterSymbol,
+  type UpdateToken,
   type WithBufferedFromOperatorObservable,
 } from '../types/index.mjs';
 import { maxDepth } from '../utils/index.mjs';
@@ -37,27 +37,27 @@ import { maxDepth } from '../utils/index.mjs';
  *
  * const result$ = trigger$.pipe(withBufferedFrom(data$));
  *
- * const mut_history: (readonly [number, readonly string[]])[] = [];
+ * const valueHistory: (readonly [number, readonly string[]])[] = [];
  *
  * result$.subscribe(([triggerValue, bufferedData]) => {
- *   mut_history.push([triggerValue, bufferedData]);
+ *   valueHistory.push([triggerValue, bufferedData]);
  * });
  *
- * data$.next('a');
+ * data$.next('A');
  *
- * data$.next('b');
+ * data$.next('B');
  *
  * trigger$.next(1);
  *
- * assert.deepStrictEqual(mut_history, [[1, ['a', 'b']]]);
+ * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);
  *
- * data$.next('c');
+ * data$.next('C');
  *
  * trigger$.next(2);
  *
- * assert.deepStrictEqual(mut_history, [
- *   [1, ['a', 'b']],
- *   [2, ['c']],
+ * assert.deepStrictEqual(valueHistory, [
+ *   [1, ['A', 'B']],
+ *   [2, ['C']],
  * ]);
  * ```
  */
@@ -71,7 +71,11 @@ export const withBufferedFrom = <A, B>(
       observable,
     )) as KeepInitialValueOperator<A, readonly [A, readonly B[]]>;
 
-export const withBuffered = withBufferedFrom; // alias
+/**
+ * Alias for `withBufferedFrom`.
+ * @see withBufferedFrom
+ */
+export const withBuffered = withBufferedFrom;
 
 class WithBufferedFromObservableClass<A, B>
   extends SyncChildObservableClass<readonly [A, readonly B[]], readonly [A]>
@@ -101,16 +105,16 @@ class WithBufferedFromObservableClass<A, B>
     });
   }
 
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
+  override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
     const sn = par.getSnapshot();
 
-    if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
       return; // skip update
     }
 
-    this.setNext([sn.value, this.#mut_bufferedValues], updaterSymbol);
+    this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
 
     this.#clearBuffer();
   }

package/src/core/operators/with-current-value-from.mts

@@ -3,7 +3,7 @@ import { SyncChildObservableClass } from '../class/index.mjs';
 import {
   type DropInitialValueOperator,
   type Observable,
-  type UpdaterSymbol,
+  type UpdateToken,
   type WithCurrentValueFromOperatorObservable,
 } from '../types/index.mjs';
 import { maxDepth } from '../utils/index.mjs';
@@ -22,14 +22,15 @@ import { maxDepth } from '../utils/index.mjs';
  * //  Timeline:
  * //
  * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30      35              40
- * //  result$             ["Alice",25]  ["Bob",30]  ["Bob",35]  ["Charlie",40]
+ * //  age$                25              30
+ * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
  * //
  * //  Explanation:
  * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the source emits
+ * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
+ * //  - Does NOT emit when the sampled observable (age$) emits
  * //  - Does not emit until both observables have emitted at least once
- * //  - Similar to combine, but only emits when the source (not the sampled) emits
+ * //  - "Alice" is skipped because age$ hasn't emitted yet
  *
  * const name$ = source<string>();
  *
@@ -37,27 +38,27 @@ import { maxDepth } from '../utils/index.mjs';
  *
  * const result$ = name$.pipe(withCurrentValueFrom(age$));
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
  * result$.subscribe(([name_, currentAge]) => {
- *   mut_history.push([name_, currentAge]);
+ *   valueHistory.push([name_, currentAge]);
  * });
  *
  * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * age$.next(25);
  *
  * name$.next('Bob'); // logs: Bob is 25 years old
  *
- * assert.deepStrictEqual(mut_history, [['Bob', 25]]);
+ * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
  *
  * age$.next(30);
  *
  * name$.next('Charlie'); // logs: Charlie is 30 years old
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   ['Bob', 25],
  *   ['Charlie', 30],
  * ]);
@@ -70,7 +71,11 @@ export const withCurrentValueFrom =
   (parentObservable) =>
     new WithCurrentValueFromObservableClass(parentObservable, observable);
 
-export const withLatestFrom = withCurrentValueFrom; // alias
+/**
+ * Alias for `withCurrentValueFrom`.
+ * @see withCurrentValueFrom
+ */
+export const withLatestFrom = withCurrentValueFrom;
 
 class WithCurrentValueFromObservableClass<A, B>
   extends SyncChildObservableClass<readonly [A, B], readonly [A]>
@@ -95,12 +100,12 @@ class WithCurrentValueFromObservableClass<A, B>
     this.#observable = observable;
   }
 
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
+  override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
     const ps = par.getSnapshot();
 
-    if (par.updaterSymbol !== updaterSymbol || Optional.isNone(ps)) {
+    if (par.updateToken !== updateToken || Optional.isNone(ps)) {
       return; // skip update
     }
 
@@ -108,6 +113,6 @@ class WithCurrentValueFromObservableClass<A, B>
 
     if (Optional.isNone(curr)) return; // skip update
 
-    this.setNext([ps.value, curr.value], updaterSymbol);
+    this.setNext([ps.value, curr.value], updateToken);
   }
 }

package/src/core/operators/with-initial-value.mts

@@ -4,7 +4,7 @@ import { source } from '../create/index.mjs';
 import {
   type InitializedObservable,
   type Observable,
-  type UpdaterSymbol,
+  type UpdateToken,
   type WithInitialValueOperator,
   type WithInitialValueOperatorObservable,
 } from '../types/index.mjs';
@@ -37,21 +37,21 @@ import {
  *
  * const initialized$ = num$.pipe(withInitialValue(0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * initialized$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
  * ```
  */
 export const withInitialValue =
@@ -70,16 +70,16 @@ class WithInitialValueObservableClass<A, I>
     });
   }
 
-  override tryUpdate(updaterSymbol: UpdaterSymbol): void {
+  override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
     const sn = par.getSnapshot();
 
-    if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
       return; // skip update
     }
 
-    this.setNext(sn.value, updaterSymbol);
+    this.setNext(sn.value, updateToken);
   }
 }
 

package/src/core/predefined/index.mts

@@ -0,0 +1 @@
+export * from './operators/index.mjs';

package/src/core/predefined/operators/attach-index.mts

@@ -0,0 +1,62 @@
+import { map } from '../../operators/index.mjs';
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+
+/**
+ * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
+ * Index starts at 0 and increments with each emission.
+ *
+ * @template A - The type of values from the source
+ * @returns An operator that emits `[index, value]` tuples
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  letter$    "A"      "B"      "C"
+ * //  indexed$   [0,"A"]  [1,"B"]  [2,"C"]
+ * //
+ * //  Explanation:
+ * //  - attachIndex attaches a sequential index to each emitted value
+ * //  - Produces [index, value] tuples
+ * //  - Index starts at 0 and increments with each emission
+ *
+ * const letter$ = source<string>();
+ *
+ * const indexed$ = letter$.pipe(attachIndex());
+ *
+ * const valueHistory: (readonly [number, string])[] = [];
+ *
+ * indexed$.subscribe(([i, letter]) => {
+ *   valueHistory.push([i, letter]);
+ * });
+ *
+ * letter$.next('A');
+ *
+ * assert.deepStrictEqual(valueHistory, [[0, 'A']]);
+ *
+ * letter$.next('B');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ * ]);
+ *
+ * letter$.next('C');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ *   [2, 'C'],
+ * ]);
+ * ```
+ */
+export const withIndex = <A,>(): KeepInitialValueOperator<
+  A,
+  readonly [SafeUint | -1, A]
+> => map((a, i) => [i, a] as const);
+
+/**
+ * Alias for `withIndex`.
+ * @see withIndex
+ */
+export const attachIndex = withIndex;

package/src/core/predefined/operators/index.mts

@@ -0,0 +1,11 @@
+export * from './attach-index.mjs';
+export * from './map-optional.mjs';
+export * from './map-result-err.mjs';
+export * from './map-result-ok.mjs';
+export * from './map-to.mjs';
+export * from './pluck.mjs';
+export * from './skip.mjs';
+export * from './take.mjs';
+export * from './unwrap-optional.mjs';
+export * from './unwrap-result-err.mjs';
+export * from './unwrap-result-ok.mjs';

package/src/core/predefined/operators/map-optional.mts

@@ -0,0 +1,55 @@
+import { Optional } from 'ts-data-forge';
+import { map } from '../../operators/index.mjs';
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+
+/**
+ * Transforms the inner value of an `Optional` type emitted by the source.
+ * If the value is `Some`, the mapping function is applied; if `None`, it remains `None`.
+ *
+ * @template O - The Optional type from the source
+ * @template B - The type of the mapped inner value
+ * @param mapFn - A function to transform the unwrapped value
+ * @returns An operator that maps the inner value of Optional emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  value$    Some(2)    None       Some(5)
+ * //  doubled$  Some(4)    None       Some(10)
+ * //
+ * //  Explanation:
+ * //  - mapOptional transforms the inner value of Optional emissions
+ * //  - Some values are mapped; None values pass through unchanged
+ *
+ * const value$ = source<Optional<number>>();
+ *
+ * const doubled$ = value$.pipe(mapOptional((x) => x * 2));
+ *
+ * const valueHistory: Optional<number>[] = [];
+ *
+ * doubled$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * value$.next(Optional.some(2));
+ *
+ * assert.deepStrictEqual(valueHistory, [Optional.some(4)]);
+ *
+ * value$.next(Optional.none);
+ *
+ * assert.deepStrictEqual(valueHistory, [Optional.some(4), Optional.none]);
+ *
+ * value$.next(Optional.some(5));
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   Optional.some(4),
+ *   Optional.none,
+ *   Optional.some(10),
+ * ]);
+ * ```
+ */
+export const mapOptional = <O extends UnknownOptional, B>(
+  mapFn: (x: Optional.Unwrap<O>) => B,
+): KeepInitialValueOperator<O, Optional<B>> =>
+  map((a) => Optional.map(a, mapFn));

package/src/core/predefined/operators/map-result-err.mts

@@ -0,0 +1,55 @@
+import { Result } from 'ts-data-forge';
+import { map } from '../../operators/index.mjs';
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+
+/**
+ * Transforms the error value (`Err`) of a `Result` type emitted by the source.
+ * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.
+ *
+ * @template R - The Result type from the source
+ * @template E2 - The type of the mapped error value
+ * @param mapFn - A function to transform the Err value
+ * @returns An operator that maps the Err side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$   Ok(1)    Err("bad")      Err("fail")
+ * //  mapped$   Ok(1)    Err("BAD")      Err("FAIL")
+ * //
+ * //  Explanation:
+ * //  - mapResultErr transforms the Err value of Result emissions
+ * //  - Ok values pass through unchanged
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));
+ *
+ * const valueHistory: Result<number, string>[] = [];
+ *
+ * mapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(1));
+ *
+ * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);
+ *
+ * result$.next(Result.err('bad'));
+ *
+ * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);
+ *
+ * result$.next(Result.err('fail'));
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   Result.ok(1),
+ *   Result.err('BAD'),
+ *   Result.err('FAIL'),
+ * ]);
+ * ```
+ */
+export const mapResultErr = <R extends UnknownResult, E2>(
+  mapFn: (x: Result.UnwrapErr<R>) => E2,
+): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>
+  map((a) => Result.mapErr(a, mapFn));

package/src/core/predefined/operators/map-result-ok.mts

@@ -0,0 +1,55 @@
+import { Result } from 'ts-data-forge';
+import { map } from '../../operators/index.mjs';
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+
+/**
+ * Transforms the success value (`Ok`) of a `Result` type emitted by the source.
+ * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.
+ *
+ * @template R - The Result type from the source
+ * @template S2 - The type of the mapped success value
+ * @param mapFn - A function to transform the Ok value
+ * @returns An operator that maps the Ok side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$   Ok(2)      Err("e")   Ok(5)
+ * //  doubled$  Ok(4)      Err("e")   Ok(10)
+ * //
+ * //  Explanation:
+ * //  - mapResultOk transforms the Ok value of Result emissions
+ * //  - Err values pass through unchanged
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));
+ *
+ * const valueHistory: Result<number, string>[] = [];
+ *
+ * doubled$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(2));
+ *
+ * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);
+ *
+ * result$.next(Result.err('e'));
+ *
+ * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);
+ *
+ * result$.next(Result.ok(5));
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   Result.ok(4),
+ *   Result.err('e'),
+ *   Result.ok(10),
+ * ]);
+ * ```
+ */
+export const mapResultOk = <R extends UnknownResult, S2>(
+  mapFn: (x: Result.UnwrapOk<R>) => S2,
+): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>
+  map((a) => Result.map(a, mapFn));

package/src/core/predefined/operators/map-to.mts

@@ -0,0 +1,45 @@
+import { map } from '../../operators/index.mjs';
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+
+/**
+ * Maps all emitted values to a constant value, ignoring the source values.
+ * Equivalent to `map(() => value)`.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of the constant value
+ * @param value - The constant value to emit
+ * @returns An operator that always emits the given constant
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  click$    MouseEvent   MouseEvent   MouseEvent
+ * //  count$    1            1            1
+ * //
+ * //  Explanation:
+ * //  - mapTo maps all emitted values to a constant value
+ * //  - Ignores the source values entirely
+ * //  - Useful for converting events to signals
+ *
+ * const click$ = source<string>();
+ *
+ * const one$ = click$.pipe(mapTo(1));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * one$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * click$.next('click1');
+ *
+ * click$.next('click2');
+ *
+ * click$.next('click3');
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
+ * ```
+ */
+export const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>
+  map(() => value);