effect 4.0.0-beta.31 → 4.0.0-beta.32

package/dist/NullOr.d.ts

@@ -1,149 +0,0 @@
-/**
- * This module provides small, allocation-free utilities for working with values of type
- * `A | null`, where `null` means "no value".
- *
- * Why not `Option<A>`?
- * In TypeScript, `Option<A>` is often unnecessary. If `null` already models absence
- * in your domain, using `A | null` keeps types simple, avoids extra wrappers, and
- * reduces overhead. The key is that `A` itself must not include `null`; in this
- * module `null` is reserved to mean "no value".
- *
- * When to use `A | null`:
- * - Absence can be represented by `null` in your domain model.
- * - You do not need to distinguish between "no value" and "value is null".
- * - You want straightforward ergonomics and zero extra allocations.
- *
- * When to prefer `Option<A>`:
- * - You must distinguish `None` from `Some(null)` (that is, `null` is a valid
- *   payload and carries meaning on its own).
- * - You need a tagged representation for serialization or pattern matching across
- *   boundaries where `null` would be ambiguous.
- * - You want the richer `Option` API and are comfortable with the extra wrapper.
- *
- * Lawfulness note:
- * All helpers treat `null` as absence. Do not use these utilities with payloads
- * where `A` can itself be `null`, or you will lose information. If you need to
- * carry `null` as a valid payload, use `Option<A>` instead.
- *
- * @since 4.0.0
- */
-import * as Combiner from "./Combiner.ts";
-import type { LazyArg } from "./Function.ts";
-import * as Reducer from "./Reducer.ts";
-/**
- * @since 4.0.0
- */
-export declare const map: {
-    /**
-     * @since 4.0.0
-     */
-    <A, B>(f: (a: A) => B): (self: A | null) => B | null;
-    /**
-     * @since 4.0.0
-     */
-    <A, B>(self: A | null, f: (a: A) => B): B | null;
-};
-/**
- * @since 4.0.0
- */
-export declare const match: {
-    /**
-     * @since 4.0.0
-     */
-    <B, A, C = B>(options: {
-        readonly onNull: LazyArg<B>;
-        readonly onNotNull: (a: A) => C;
-    }): (self: A | null) => B | C;
-    /**
-     * @since 4.0.0
-     */
-    <A, B, C = B>(self: A | null, options: {
-        readonly onNull: LazyArg<B>;
-        readonly onNotNull: (a: A) => C;
-    }): B | C;
-};
-/**
- * @since 4.0.0
- */
-export declare const getOrThrowWith: {
-    /**
-     * @since 4.0.0
-     */
-    (onNull: () => unknown): <A>(self: A | null) => A;
-    /**
-     * @since 4.0.0
-     */
-    <A>(self: A | null, onNull: () => unknown): A;
-};
-/**
- * @since 4.0.0
- */
-export declare const getOrThrow: <A>(self: A | null) => A;
-/**
- * @since 4.0.0
- */
-export declare const liftThrowable: <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B) => (...a: A) => B | null;
-/**
- * Creates a `Reducer` for `NullOr<A>` that prioritizes the first non-`null`
- * value and combines values when both operands are present.
- *
- * This `Reducer` is useful for scenarios where you want to:
- * - Take the first available value (like a fallback chain)
- * - Combine values when both are present
- * - Maintain a `null` state only when all values are `null`
- *
- * The `initialValue` of the `Reducer` is `null`.
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `a` (first value wins)
- * - `null` + `b` = `b` (second value wins)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @since 4.0.0
- */
-export declare function makeReducer<A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<A | null>;
-/**
- * Creates a `Combiner` for `NullOr<A>` that only combines values when both
- * operands are not `null`, failing fast if either is `null`.
- *
- * This `Combiner` is useful for scenarios where you need both values to be
- * present to perform an operation, such as:
- * - Mathematical operations that require two operands
- * - Data validation that needs both fields
- * - Operations that can't proceed with partial data
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `null` (fails fast)
- * - `null` + `b` = `null` (fails fast)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @see {@link makeReducerFailFast} if you have a `Reducer` and want to lift it
- * to `NullOr` values.
- *
- * @since 4.0.0
- */
-export declare function makeCombinerFailFast<A>(combiner: Combiner.Combiner<A>): Combiner.Combiner<A | null>;
-/**
- * Creates a `Reducer` for `NullOr<A>` by wrapping an existing `Reducer` with
- * fail-fast semantics for `NullOr` values.
- *
- * This function lifts a regular `Reducer` into the `NullOr` context, allowing
- * you to use existing `Reducer`s with `NullOr` values while maintaining the
- * fail-fast behavior where any `null` value causes the entire reduction to fail.
- *
- * The initial value is `some(reducer.initialValue)`, ensuring the `Reducer`
- * starts with a valid `NullOr` value.
- *
- * **Behavior:**
- * - Fails fast (returns `null`) if any operand is `null`
- * - Uses the underlying reducer's combine logic when both values are present
- *
- * @see {@link makeCombinerFailFast} if you only have a `Combiner` and want to
- * lift it to `NullOr` values.
- *
- * @since 4.0.0
- */
-export declare function makeReducerFailFast<A>(reducer: Reducer.Reducer<A>): Reducer.Reducer<A | null>;
-//# sourceMappingURL=NullOr.d.ts.map

package/dist/NullOr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NullOr.d.ts","sourceRoot":"","sources":["../src/NullOr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,CAAA;IACpD;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;CACQ,CAAA;AAE1D;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,OAAO,EAAE;QACP,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC3B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;KAChC,GACA,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAA;IAC5B;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,IAAI,EAAE,CAAC,GAAG,IAAI,EACd,OAAO,EAAE;QACP,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC3B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;KAChC,GACA,CAAC,GAAG,CAAC,CAAA;CAOT,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;OAEG;IACH,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,CAAA;IACjD;;OAEG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,OAAO,GAAG,CAAC,CAAA;CAM7C,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAkE,CAAA;AAElH;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,EAC/D,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,KAChB,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAOnB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAMxF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,CAKnG;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAW7F"}

package/dist/NullOr.js

@@ -1,152 +0,0 @@
-/**
- * This module provides small, allocation-free utilities for working with values of type
- * `A | null`, where `null` means "no value".
- *
- * Why not `Option<A>`?
- * In TypeScript, `Option<A>` is often unnecessary. If `null` already models absence
- * in your domain, using `A | null` keeps types simple, avoids extra wrappers, and
- * reduces overhead. The key is that `A` itself must not include `null`; in this
- * module `null` is reserved to mean "no value".
- *
- * When to use `A | null`:
- * - Absence can be represented by `null` in your domain model.
- * - You do not need to distinguish between "no value" and "value is null".
- * - You want straightforward ergonomics and zero extra allocations.
- *
- * When to prefer `Option<A>`:
- * - You must distinguish `None` from `Some(null)` (that is, `null` is a valid
- *   payload and carries meaning on its own).
- * - You need a tagged representation for serialization or pattern matching across
- *   boundaries where `null` would be ambiguous.
- * - You want the richer `Option` API and are comfortable with the extra wrapper.
- *
- * Lawfulness note:
- * All helpers treat `null` as absence. Do not use these utilities with payloads
- * where `A` can itself be `null`, or you will lose information. If you need to
- * carry `null` as a valid payload, use `Option<A>` instead.
- *
- * @since 4.0.0
- */
-import * as Combiner from "./Combiner.js";
-import { dual } from "./Function.js";
-import * as Reducer from "./Reducer.js";
-/**
- * @since 4.0.0
- */
-export const map = /*#__PURE__*/dual(2, (self, f) => self === null ? null : f(self));
-/**
- * @since 4.0.0
- */
-export const match = /*#__PURE__*/dual(2, (self, {
-  onNotNull,
-  onNull
-}) => self === null ? onNull() : onNotNull(self));
-/**
- * @since 4.0.0
- */
-export const getOrThrowWith = /*#__PURE__*/dual(2, (self, onNull) => {
-  if (self !== null) {
-    return self;
-  }
-  throw onNull();
-});
-/**
- * @since 4.0.0
- */
-export const getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error("getOrThrow called on a null"));
-/**
- * @since 4.0.0
- */
-export const liftThrowable = f => (...a) => {
-  try {
-    return f(...a);
-  } catch {
-    return null;
-  }
-};
-/**
- * Creates a `Reducer` for `NullOr<A>` that prioritizes the first non-`null`
- * value and combines values when both operands are present.
- *
- * This `Reducer` is useful for scenarios where you want to:
- * - Take the first available value (like a fallback chain)
- * - Combine values when both are present
- * - Maintain a `null` state only when all values are `null`
- *
- * The `initialValue` of the `Reducer` is `null`.
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `a` (first value wins)
- * - `null` + `b` = `b` (second value wins)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @since 4.0.0
- */
-export function makeReducer(combiner) {
-  return Reducer.make((self, that) => {
-    if (self === null) return that;
-    if (that === null) return self;
-    return combiner.combine(self, that);
-  }, null);
-}
-/**
- * Creates a `Combiner` for `NullOr<A>` that only combines values when both
- * operands are not `null`, failing fast if either is `null`.
- *
- * This `Combiner` is useful for scenarios where you need both values to be
- * present to perform an operation, such as:
- * - Mathematical operations that require two operands
- * - Data validation that needs both fields
- * - Operations that can't proceed with partial data
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `null` (fails fast)
- * - `null` + `b` = `null` (fails fast)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @see {@link makeReducerFailFast} if you have a `Reducer` and want to lift it
- * to `NullOr` values.
- *
- * @since 4.0.0
- */
-export function makeCombinerFailFast(combiner) {
-  return Combiner.make((self, that) => {
-    if (self === null || that === null) return null;
-    return combiner.combine(self, that);
-  });
-}
-/**
- * Creates a `Reducer` for `NullOr<A>` by wrapping an existing `Reducer` with
- * fail-fast semantics for `NullOr` values.
- *
- * This function lifts a regular `Reducer` into the `NullOr` context, allowing
- * you to use existing `Reducer`s with `NullOr` values while maintaining the
- * fail-fast behavior where any `null` value causes the entire reduction to fail.
- *
- * The initial value is `some(reducer.initialValue)`, ensuring the `Reducer`
- * starts with a valid `NullOr` value.
- *
- * **Behavior:**
- * - Fails fast (returns `null`) if any operand is `null`
- * - Uses the underlying reducer's combine logic when both values are present
- *
- * @see {@link makeCombinerFailFast} if you only have a `Combiner` and want to
- * lift it to `NullOr` values.
- *
- * @since 4.0.0
- */
-export function makeReducerFailFast(reducer) {
-  const combine = makeCombinerFailFast(reducer).combine;
-  const initialValue = reducer.initialValue;
-  return Reducer.make(combine, initialValue, collection => {
-    let out = initialValue;
-    for (const value of collection) {
-      out = combine(out, value);
-      if (out === null) return out;
-    }
-    return out;
-  });
-}
-//# sourceMappingURL=NullOr.js.map

package/dist/NullOr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NullOr.js","names":["Combiner","dual","Reducer","map","self","f","match","onNotNull","onNull","getOrThrowWith","getOrThrow","Error","liftThrowable","a","makeReducer","combiner","make","that","combine","makeCombinerFailFast","makeReducerFailFast","reducer","initialValue","collection","out","value"],"sources":["../src/NullOr.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,OAAO,KAAKA,QAAQ,MAAM,eAAe;AAEzC,SAASC,IAAI,QAAQ,eAAe;AACpC,OAAO,KAAKC,OAAO,MAAM,cAAc;AAEvC;;;AAGA,OAAO,MAAMC,GAAG,gBASZF,IAAI,CAAC,CAAC,EAAE,CAACG,IAAI,EAAEC,CAAC,KAAMD,IAAI,KAAK,IAAI,GAAG,IAAI,GAAGC,CAAC,CAACD,IAAI,CAAE,CAAC;AAE1D;;;AAGA,OAAO,MAAME,KAAK,gBAoBdL,IAAI,CACN,CAAC,EACD,CAAcG,IAAc,EAAE;EAAEG,SAAS;EAAEC;AAAM,CAGhD,KAAYJ,IAAI,KAAK,IAAI,GAAGI,MAAM,EAAE,GAAGD,SAAS,CAACH,IAAI,CAAC,CACxD;AAED;;;AAGA,OAAO,MAAMK,cAAc,gBASvBR,IAAI,CAAC,CAAC,EAAE,CAAIG,IAAc,EAAEI,MAAqB,KAAO;EAC1D,IAAIJ,IAAI,KAAK,IAAI,EAAE;IACjB,OAAOA,IAAI;EACb;EACA,MAAMI,MAAM,EAAE;AAChB,CAAC,CAAC;AAEF;;;AAGA,OAAO,MAAME,UAAU,gBAA6BD,cAAc,CAAC,MAAM,IAAIE,KAAK,CAAC,6BAA6B,CAAC,CAAC;AAElH;;;AAGA,OAAO,MAAMC,aAAa,GACxBP,CAAiB,IAEnB,CAAC,GAAGQ,CAAC,KAAI;EACP,IAAI;IACF,OAAOR,CAAC,CAAC,GAAGQ,CAAC,CAAC;EAChB,CAAC,CAAC,MAAM;IACN,OAAO,IAAI;EACb;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;;AAmBA,OAAM,SAAUC,WAAWA,CAAIC,QAA8B;EAC3D,OAAOb,OAAO,CAACc,IAAI,CAAC,CAACZ,IAAI,EAAEa,IAAI,KAAI;IACjC,IAAIb,IAAI,KAAK,IAAI,EAAE,OAAOa,IAAI;IAC9B,IAAIA,IAAI,KAAK,IAAI,EAAE,OAAOb,IAAI;IAC9B,OAAOW,QAAQ,CAACG,OAAO,CAACd,IAAI,EAAEa,IAAI,CAAC;EACrC,CAAC,EAAE,IAAgB,CAAC;AACtB;AAEA;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAM,SAAUE,oBAAoBA,CAAIJ,QAA8B;EACpE,OAAOf,QAAQ,CAACgB,IAAI,CAAC,CAACZ,IAAI,EAAEa,IAAI,KAAI;IAClC,IAAIb,IAAI,KAAK,IAAI,IAAIa,IAAI,KAAK,IAAI,EAAE,OAAO,IAAI;IAC/C,OAAOF,QAAQ,CAACG,OAAO,CAACd,IAAI,EAAEa,IAAI,CAAC;EACrC,CAAC,CAAC;AACJ;AAEA;;;;;;;;;;;;;;;;;;;;AAoBA,OAAM,SAAUG,mBAAmBA,CAAIC,OAA2B;EAChE,MAAMH,OAAO,GAAGC,oBAAoB,CAACE,OAAO,CAAC,CAACH,OAAO;EACrD,MAAMI,YAAY,GAAGD,OAAO,CAACC,YAAwB;EACrD,OAAOpB,OAAO,CAACc,IAAI,CAACE,OAAO,EAAEI,YAAY,EAAGC,UAAU,IAAI;IACxD,IAAIC,GAAG,GAAGF,YAAY;IACtB,KAAK,MAAMG,KAAK,IAAIF,UAAU,EAAE;MAC9BC,GAAG,GAAGN,OAAO,CAACM,GAAG,EAAEC,KAAK,CAAC;MACzB,IAAID,GAAG,KAAK,IAAI,EAAE,OAAOA,GAAG;IAC9B;IACA,OAAOA,GAAG;EACZ,CAAC,CAAC;AACJ","ignoreList":[]}

package/src/NullOr.ts

@@ -1,204 +0,0 @@
-/**
- * This module provides small, allocation-free utilities for working with values of type
- * `A | null`, where `null` means "no value".
- *
- * Why not `Option<A>`?
- * In TypeScript, `Option<A>` is often unnecessary. If `null` already models absence
- * in your domain, using `A | null` keeps types simple, avoids extra wrappers, and
- * reduces overhead. The key is that `A` itself must not include `null`; in this
- * module `null` is reserved to mean "no value".
- *
- * When to use `A | null`:
- * - Absence can be represented by `null` in your domain model.
- * - You do not need to distinguish between "no value" and "value is null".
- * - You want straightforward ergonomics and zero extra allocations.
- *
- * When to prefer `Option<A>`:
- * - You must distinguish `None` from `Some(null)` (that is, `null` is a valid
- *   payload and carries meaning on its own).
- * - You need a tagged representation for serialization or pattern matching across
- *   boundaries where `null` would be ambiguous.
- * - You want the richer `Option` API and are comfortable with the extra wrapper.
- *
- * Lawfulness note:
- * All helpers treat `null` as absence. Do not use these utilities with payloads
- * where `A` can itself be `null`, or you will lose information. If you need to
- * carry `null` as a valid payload, use `Option<A>` instead.
- *
- * @since 4.0.0
- */
-import * as Combiner from "./Combiner.ts"
-import type { LazyArg } from "./Function.ts"
-import { dual } from "./Function.ts"
-import * as Reducer from "./Reducer.ts"
-
-/**
- * @since 4.0.0
- */
-export const map: {
-  /**
-   * @since 4.0.0
-   */
-  <A, B>(f: (a: A) => B): (self: A | null) => B | null
-  /**
-   * @since 4.0.0
-   */
-  <A, B>(self: A | null, f: (a: A) => B): B | null
-} = dual(2, (self, f) => (self === null ? null : f(self)))
-
-/**
- * @since 4.0.0
- */
-export const match: {
-  /**
-   * @since 4.0.0
-   */
-  <B, A, C = B>(
-    options: {
-      readonly onNull: LazyArg<B>
-      readonly onNotNull: (a: A) => C
-    }
-  ): (self: A | null) => B | C
-  /**
-   * @since 4.0.0
-   */
-  <A, B, C = B>(
-    self: A | null,
-    options: {
-      readonly onNull: LazyArg<B>
-      readonly onNotNull: (a: A) => C
-    }
-  ): B | C
-} = dual(
-  2,
-  <A, B, C = B>(self: A | null, { onNotNull, onNull }: {
-    readonly onNull: LazyArg<B>
-    readonly onNotNull: (a: A) => C
-  }): B | C => self === null ? onNull() : onNotNull(self)
-)
-
-/**
- * @since 4.0.0
- */
-export const getOrThrowWith: {
-  /**
-   * @since 4.0.0
-   */
-  (onNull: () => unknown): <A>(self: A | null) => A
-  /**
-   * @since 4.0.0
-   */
-  <A>(self: A | null, onNull: () => unknown): A
-} = dual(2, <A>(self: A | null, onNull: () => unknown): A => {
-  if (self !== null) {
-    return self
-  }
-  throw onNull()
-})
-
-/**
- * @since 4.0.0
- */
-export const getOrThrow: <A>(self: A | null) => A = getOrThrowWith(() => new Error("getOrThrow called on a null"))
-
-/**
- * @since 4.0.0
- */
-export const liftThrowable = <A extends ReadonlyArray<unknown>, B>(
-  f: (...a: A) => B
-): (...a: A) => B | null =>
-(...a) => {
-  try {
-    return f(...a)
-  } catch {
-    return null
-  }
-}
-
-/**
- * Creates a `Reducer` for `NullOr<A>` that prioritizes the first non-`null`
- * value and combines values when both operands are present.
- *
- * This `Reducer` is useful for scenarios where you want to:
- * - Take the first available value (like a fallback chain)
- * - Combine values when both are present
- * - Maintain a `null` state only when all values are `null`
- *
- * The `initialValue` of the `Reducer` is `null`.
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `a` (first value wins)
- * - `null` + `b` = `b` (second value wins)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @since 4.0.0
- */
-export function makeReducer<A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<A | null> {
-  return Reducer.make((self, that) => {
-    if (self === null) return that
-    if (that === null) return self
-    return combiner.combine(self, that)
-  }, null as A | null)
-}
-
-/**
- * Creates a `Combiner` for `NullOr<A>` that only combines values when both
- * operands are not `null`, failing fast if either is `null`.
- *
- * This `Combiner` is useful for scenarios where you need both values to be
- * present to perform an operation, such as:
- * - Mathematical operations that require two operands
- * - Data validation that needs both fields
- * - Operations that can't proceed with partial data
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `null` (fails fast)
- * - `null` + `b` = `null` (fails fast)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @see {@link makeReducerFailFast} if you have a `Reducer` and want to lift it
- * to `NullOr` values.
- *
- * @since 4.0.0
- */
-export function makeCombinerFailFast<A>(combiner: Combiner.Combiner<A>): Combiner.Combiner<A | null> {
-  return Combiner.make((self, that) => {
-    if (self === null || that === null) return null
-    return combiner.combine(self, that)
-  })
-}
-
-/**
- * Creates a `Reducer` for `NullOr<A>` by wrapping an existing `Reducer` with
- * fail-fast semantics for `NullOr` values.
- *
- * This function lifts a regular `Reducer` into the `NullOr` context, allowing
- * you to use existing `Reducer`s with `NullOr` values while maintaining the
- * fail-fast behavior where any `null` value causes the entire reduction to fail.
- *
- * The initial value is `some(reducer.initialValue)`, ensuring the `Reducer`
- * starts with a valid `NullOr` value.
- *
- * **Behavior:**
- * - Fails fast (returns `null`) if any operand is `null`
- * - Uses the underlying reducer's combine logic when both values are present
- *
- * @see {@link makeCombinerFailFast} if you only have a `Combiner` and want to
- * lift it to `NullOr` values.
- *
- * @since 4.0.0
- */
-export function makeReducerFailFast<A>(reducer: Reducer.Reducer<A>): Reducer.Reducer<A | null> {
-  const combine = makeCombinerFailFast(reducer).combine
-  const initialValue = reducer.initialValue as A | null
-  return Reducer.make(combine, initialValue, (collection) => {
-    let out = initialValue
-    for (const value of collection) {
-      out = combine(out, value)
-      if (out === null) return out
-    }
-    return out
-  })
-}