effect 4.0.0-beta.31 → 4.0.0-beta.33

package/src/unstable/workflow/WorkflowEngine.ts

@@ -98,7 +98,7 @@ export class WorkflowEngine extends ServiceMap.Service<
       workflow: Workflow.Workflow<Name, Payload, Success, Error>,
       executionId: string
     ) => Effect.Effect<
-      Workflow.Result<Success["Type"], Error["Type"]> | undefined,
+      Option.Option<Workflow.Result<Success["Type"], Error["Type"]>>,
       never,
       Success["DecodingServices"] | Error["DecodingServices"]
     >
@@ -147,7 +147,7 @@ export class WorkflowEngine extends ServiceMap.Service<
     >(
       deferred: DurableDeferred.DurableDeferred<Success, Error>
     ) => Effect.Effect<
-      Exit.Exit<Success["Type"], Error["Type"]> | undefined,
+      Option.Option<Exit.Exit<Success["Type"], Error["Type"]>>,
       never,
       WorkflowInstance
     >
@@ -277,7 +277,7 @@ export interface Encoded {
   readonly poll: (
     workflow: Workflow.Any,
     executionId: string
-  ) => Effect.Effect<Workflow.Result<unknown, unknown> | undefined>
+  ) => Effect.Effect<Option.Option<Workflow.Result<unknown, unknown>>>
   readonly interrupt: (
     workflow: Workflow.Any,
     executionId: string
@@ -297,7 +297,7 @@ export interface Encoded {
   readonly deferredResult: (
     deferred: DurableDeferred.Any
   ) => Effect.Effect<
-    Exit.Exit<unknown, unknown> | undefined,
+    Option.Option<Exit.Exit<unknown, unknown>>,
     never,
     WorkflowInstance
   >
@@ -354,14 +354,14 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
       const executionId = opts.executionId
       const suspendedRetrySchedule = opts.suspendedRetrySchedule ?? defaultRetrySchedule
       yield* Effect.annotateCurrentSpan({ executionId })
-      let result: Workflow.Result<Success["Type"], Error["Type"]> | undefined
+      let result = Option.none<Workflow.Result<Success["Type"], Error["Type"]>>()
 
       // link interruption with parent workflow
       const parentInstance = yield* Effect.serviceOption(WorkflowInstance)
       if (Option.isSome(parentInstance)) {
         const instance = parentInstance.value
         yield* Effect.addFinalizer(() => {
-          if (!instance.interrupted || result?._tag === "Complete") {
+          if (!instance.interrupted || (Option.isSome(result) && result.value._tag === "Complete")) {
             return Effect.void
           }
           return options.interrupt(self, executionId)
@@ -384,21 +384,23 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
         parent: Option.getOrUndefined(parentInstance)
       })
       if (Option.isSome(parentInstance)) {
-        result = yield* Workflow.wrapActivityResult(
+        const wrapped = yield* Workflow.wrapActivityResult(
           run,
           (result) => result._tag === "Suspended"
         )
-        if (result._tag === "Suspended") {
+        result = Option.some(wrapped)
+        if (wrapped._tag === "Suspended") {
           return yield* Workflow.suspend(parentInstance.value)
         }
-        return yield* result.exit
+        return yield* wrapped.exit
       }
 
       let sleep: Effect.Effect<any> | undefined
       while (true) {
-        result = yield* run
-        if (result._tag === "Complete") {
-          return yield* result.exit as Exit.Exit<any>
+        const wrapped = yield* run
+        result = Option.some(wrapped)
+        if (wrapped._tag === "Complete") {
+          return yield* wrapped.exit as Exit.Exit<any>
         }
         sleep ??= (yield* Schedule.toStepWithSleep(suspendedRetrySchedule))(
           void 0
@@ -438,12 +440,14 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
           executionId: instance.executionId
         })
         const exit = yield* options.deferredResult(deferred)
-        if (exit === undefined) {
-          return exit
+        if (Option.isNone(exit)) {
+          return Option.none()
         }
-        return yield* Effect.orDie(
-          Schema.decodeEffect(deferred.exitSchema)(toJsonExit(exit))
-        ) as Effect.Effect<Exit.Exit<Success["Type"], Error["Type"]>>
+        return Option.some(
+          yield* Effect.orDie(
+            Schema.decodeEffect(deferred.exitSchema)(toJsonExit(exit.value))
+          ) as Effect.Effect<Exit.Exit<Success["Type"], Error["Type"]>>
+        )
       },
       Effect.withSpan(
         "WorkflowEngine.deferredResult",
@@ -646,15 +650,20 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
         Effect.suspend(() => {
           const state = executions.get(executionId)
           if (!state) {
-            return Effect.succeed(undefined)
+            return Effect.succeedNone
           }
           const exit = state.fiber?.pollUnsafe()
-          return exit ?? Effect.succeed(undefined)
+          if (!exit) {
+            return Effect.succeedNone
+          }
+          return exit._tag === "Success"
+            ? Effect.succeedSome(exit.value)
+            : Effect.die(exit.cause)
         }),
       deferredResult: Effect.fnUntraced(function*(deferred) {
         const instance = yield* WorkflowInstance
         const id = `${instance.executionId}/${deferred.name}`
-        return deferredResults.get(id)
+        return Option.fromNullishOr(deferredResults.get(id))
       }),
       deferredDone: (options) =>
         Effect.suspend(() => {

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
-  })
-}