@nunofyobiz/effect-extras 2.1.0 → 3.1.0

package/src/WarnResult.ts

@@ -4,8 +4,9 @@
  *
  * @since 0.0.0
  */
-import { Data, Effect, Option, Predicate, Struct, pipe } from "effect";
-import { constUndefined, identity } from "effect/Function";
+import { Data, Effect, Option, pipe } from "effect";
+import { dual } from "effect/Function";
+import * as InclusiveOr from "./InclusiveOr.js";
 
 /**
  * A result that may come with a success value and may come with warnings — both
@@ -23,7 +24,7 @@ import { constUndefined, identity } from "effect/Function";
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const both: WarnResult.WarnResult<string, number> =
+ * const both: WarnResult.WarnResult<number, string> =
  *   WarnResult.SuccessWithWarnings({
  *     warnings: "rounded down",
  *     success: 1
@@ -35,7 +36,7 @@ import { constUndefined, identity } from "effect/Function";
  * @category models
  * @since 0.0.0
  */
-export type WarnResult<W, A> = Data.TaggedEnum<{
+export type WarnResult<A, W> = Data.TaggedEnum<{
   WarningsOnly: {
     readonly warnings: W;
   };
@@ -68,7 +69,7 @@ export type WarnResult<W, A> = Data.TaggedEnum<{
  * @category models
  * @since 0.0.0
  */
-export type WarningsOnly<W> = WarnResult<W, never> & {
+export type WarningsOnly<W> = WarnResult<never, W> & {
   _tag: "WarningsOnly";
 };
 
@@ -90,7 +91,7 @@ export type WarningsOnly<W> = WarnResult<W, never> & {
  * @category models
  * @since 0.0.0
  */
-export type SuccessOnly<A> = WarnResult<never, A> & {
+export type SuccessOnly<A> = WarnResult<A, never> & {
   _tag: "SuccessOnly";
 };
 
@@ -102,7 +103,7 @@ export type SuccessOnly<A> = WarnResult<never, A> & {
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.SuccessWithWarnings<string, number> =
+ * const value: WarnResult.SuccessWithWarnings<number, string> =
  *   WarnResult.SuccessWithWarnings({
  *     warnings: "rounded down",
  *     success: 1
@@ -118,7 +119,7 @@ export type SuccessOnly<A> = WarnResult<never, A> & {
  * @category models
  * @since 0.0.0
  */
-export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
+export type SuccessWithWarnings<A, W> = WarnResult<A, W> & {
   _tag: "SuccessWithWarnings";
 };
 
@@ -130,7 +131,7 @@ export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.WithWarnings<string, number> = WarnResult.WarningsOnly({
+ * const value: WarnResult.WithWarnings<number, string> = WarnResult.WarningsOnly({
  *   warnings: "skipped 2 rows"
  * })
  *
@@ -140,7 +141,7 @@ export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
  * @category models
  * @since 0.0.0
  */
-export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
+export type WithWarnings<A, W> = WarningsOnly<W> | SuccessWithWarnings<A, W>;
 
 /**
  * Any `WarnResult` that is guaranteed to carry a `success` value — either
@@ -150,7 +151,7 @@ export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.WithSuccess<string, number> = WarnResult.SuccessOnly({
+ * const value: WarnResult.WithSuccess<number, string> = WarnResult.SuccessOnly({
  *   success: 1
  * })
  *
@@ -160,7 +161,7 @@ export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
  * @category models
  * @since 0.0.0
  */
-export type WithSuccess<W, A> = SuccessOnly<A> | SuccessWithWarnings<W, A>;
+export type WithSuccess<A, W> = SuccessOnly<A> | SuccessWithWarnings<A, W>;
 
 interface WarnResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
   readonly taggedEnum: WarnResult<this["A"], this["B"]>;
@@ -277,6 +278,60 @@ export const is = taggedEnum.$is;
  */
 export const match = taggedEnum.$match;
 
+/**
+ * Relabels a `WarnResult` as the equivalent terminology-free `InclusiveOr`,
+ * mapping `warnings` to `left` and `success` to `right`. The inverse of
+ * `fromInclusiveOr`.
+ *
+ * `WarnResult` is the use-case-driven (`warnings`/`success`) face of the generic
+ * `InclusiveOr` (`left`/`right`); every derived `WarnResult` operation is just this
+ * relabeling around the corresponding `InclusiveOr` operation, so all the logic
+ * lives in `InclusiveOr` and is never duplicated here.
+ */
+const toInclusiveOr = <A, W>(
+  warnResult: WarnResult<A, W>,
+): InclusiveOr.InclusiveOr<W, A> =>
+  match(warnResult, {
+    WarningsOnly: ({ warnings }) => InclusiveOr.LeftOnly({ left: warnings }),
+    SuccessOnly: ({ success }) => InclusiveOr.RightOnly({ right: success }),
+    SuccessWithWarnings: ({ warnings, success }) =>
+      InclusiveOr.LeftAndRight({ left: warnings, right: success }),
+  });
+
+/**
+ * Relabels an `InclusiveOr` as the equivalent `WarnResult`, mapping `left` to
+ * `warnings` and `right` to `success`. The inverse of `toInclusiveOr`.
+ *
+ * Overloaded so the precise member subtype survives the round trip — e.g. an
+ * `InclusiveOr.LeftAndRight` becomes a `SuccessWithWarnings` rather than a widened
+ * `WarnResult` — which keeps the delegating helpers' return types as exact as the
+ * hand-written ones were.
+ */
+function fromInclusiveOr<W>(io: InclusiveOr.LeftOnly<W>): WarningsOnly<W>;
+function fromInclusiveOr<A>(io: InclusiveOr.RightOnly<A>): SuccessOnly<A>;
+function fromInclusiveOr<A, W>(
+  io: InclusiveOr.LeftAndRight<W, A>,
+): SuccessWithWarnings<A, W>;
+function fromInclusiveOr<A, W>(
+  io: InclusiveOr.WithLeft<W, A>,
+): WithWarnings<A, W>;
+function fromInclusiveOr<A, W>(
+  io: InclusiveOr.WithRight<W, A>,
+): WithSuccess<A, W>;
+function fromInclusiveOr<A, W>(
+  io: InclusiveOr.InclusiveOr<W, A>,
+): WarnResult<A, W>;
+function fromInclusiveOr<A, W>(
+  io: InclusiveOr.InclusiveOr<W, A>,
+): WarnResult<A, W> {
+  return InclusiveOr.match(io, {
+    LeftOnly: ({ left }) => WarningsOnly({ warnings: left }),
+    RightOnly: ({ right }) => SuccessOnly({ success: right }),
+    LeftAndRight: ({ left, right }) =>
+      SuccessWithWarnings({ warnings: left, success: right }),
+  });
+}
+
 /**
  * Builds a `WarnResult` known to carry `warnings`, choosing `SuccessWithWarnings`
  * when a `success` value is present and `WarningsOnly` otherwise.
@@ -284,7 +339,7 @@ export const match = taggedEnum.$match;
  * Use it when the `warnings` are mandatory and the `success` value is an optional
  * companion: pass an absent (`null`/`undefined`) `success` to get a
  * `WarningsOnly`, or a present one to get a `SuccessWithWarnings`. The return type
- * `WithWarnings<W, A>` reflects that `warnings` are always present.
+ * `WithWarnings<A, W>` reflects that `warnings` are always present.
  *
  * @example
  * ```ts
@@ -304,16 +359,14 @@ export const match = taggedEnum.$match;
  * @category constructors
  * @since 0.0.0
  */
-export const WithWarnings = <W, A>({
+export const WithWarnings = <A, W>({
   warnings,
   success,
 }: {
   warnings: W;
   success?: A | undefined;
-}): WithWarnings<W, A> =>
-  Predicate.isNotNullish(success)
-    ? SuccessWithWarnings({ warnings, success })
-    : WarningsOnly({ warnings });
+}): WithWarnings<A, W> =>
+  fromInclusiveOr(InclusiveOr.WithLeft({ left: warnings, right: success }));
 
 /**
  * Builds a `WarnResult` known to carry a `success` value, choosing
@@ -322,7 +375,7 @@ export const WithWarnings = <W, A>({
  * The mirror of `WithWarnings`: the `success` value is mandatory and the
  * `warnings` are an optional companion. Pass absent (`null`/`undefined`)
  * `warnings` to get a `SuccessOnly`, or present ones to get a
- * `SuccessWithWarnings`. The return type `WithSuccess<W, A>` reflects that a
+ * `SuccessWithWarnings`. The return type `WithSuccess<A, W>` reflects that a
  * `success` value is always present.
  *
  * @example
@@ -343,16 +396,14 @@ export const WithWarnings = <W, A>({
  * @category constructors
  * @since 0.0.0
  */
-export const WithSuccess = <W, A>({
+export const WithSuccess = <A, W>({
   warnings,
   success,
 }: {
   warnings?: W | undefined;
   success: A;
-}): WithSuccess<W, A> =>
-  Predicate.isNotNullish(warnings)
-    ? SuccessWithWarnings({ warnings, success })
-    : SuccessOnly({ success });
+}): WithSuccess<A, W> =>
+  fromInclusiveOr(InclusiveOr.WithRight({ left: warnings, right: success }));
 
 /**
  * Builds a `WarnResult` from a pair of possibly-nullish inputs, wrapping the
@@ -388,24 +439,17 @@ export const WithSuccess = <W, A>({
  * @category constructors
  * @since 0.0.0
  */
-export const optionFromNullables = <W, A>({
+export const optionFromNullables = <A, W>({
   warnings,
   success,
 }: {
   warnings?: W | null | undefined;
   success?: A | null | undefined;
-}): Option.Option<WarnResult<W, A>> => {
-  if (Predicate.isNotNullish(warnings) && Predicate.isNotNullish(success)) {
-    return Option.some(SuccessWithWarnings({ warnings, success }));
-  }
-  if (Predicate.isNotNullish(warnings)) {
-    return Option.some(WarningsOnly({ warnings }));
-  }
-  if (Predicate.isNotNullish(success)) {
-    return Option.some(SuccessOnly({ success }));
-  }
-  return Option.none();
-};
+}): Option.Option<WarnResult<A, W>> =>
+  Option.map(
+    InclusiveOr.optionFromNullables({ left: warnings, right: success }),
+    (io) => fromInclusiveOr(io),
+  );
 
 /**
  * Builds a `WarnResult` from a pair of possibly-nullish inputs, falling back to
@@ -439,7 +483,7 @@ export const optionFromNullables = <W, A>({
  * @category constructors
  * @since 0.0.0
  */
-export const fromNullables = <W, A>({
+export const fromNullables = <A, W>({
   warnings,
   success,
   orElse = () => {
@@ -448,8 +492,8 @@ export const fromNullables = <W, A>({
 }: {
   warnings?: W | null | undefined;
   success?: A | null | undefined;
-  orElse?: () => WarnResult<W, A>;
-}): WarnResult<W, A> =>
+  orElse?: () => WarnResult<A, W>;
+}): WarnResult<A, W> =>
   pipe(optionFromNullables({ warnings, success }), Option.getOrElse(orElse));
 
 /**
@@ -488,25 +532,16 @@ export const fromNullables = <W, A>({
  * @since 0.0.0
  */
 export const matchWarnings =
-  <W, A, Z>({
+  <A, W, Z>({
     Warnings,
     SuccessOnly,
   }: {
     Warnings: (warnings: W) => Z;
     SuccessOnly: (success: A) => Z;
   }) =>
-  (warnResult: WarnResult<W, A>): Z =>
-    pipe(
-      warnResult,
-
-      match({
-        WarningsOnly: ({ warnings }) => Warnings(warnings),
-        SuccessOnly: ({ success }) => SuccessOnly(success),
-        SuccessWithWarnings: ({ warnings }) => Warnings(warnings),
-      }),
-
-      // Make Typescript happy
-      (a) => a as Z,
+  (warnResult: WarnResult<A, W>): Z =>
+    InclusiveOr.matchLeft({ Left: Warnings, RightOnly: SuccessOnly })(
+      toInclusiveOr(warnResult),
     );
 
 /**
@@ -546,25 +581,16 @@ export const matchWarnings =
  * @since 0.0.0
  */
 export const matchSuccess =
-  <W, A, Z>({
+  <A, W, Z>({
     WarningsOnly,
     Success,
   }: {
     WarningsOnly: (warnings: W) => Z;
     Success: (success: A) => Z;
   }) =>
-  (warnResult: WarnResult<W, A>): Z =>
-    pipe(
-      warnResult,
-
-      match({
-        WarningsOnly: ({ warnings }) => WarningsOnly(warnings),
-        SuccessOnly: ({ success }) => Success(success),
-        SuccessWithWarnings: ({ success }) => Success(success),
-      }),
-
-      // Make Typescript happy
-      (a) => a as Z,
+  (warnResult: WarnResult<A, W>): Z =>
+    InclusiveOr.matchRight({ LeftOnly: WarningsOnly, Right: Success })(
+      toInclusiveOr(warnResult),
     );
 
 /**
@@ -598,23 +624,23 @@ export const matchSuccess =
  * @category getters
  * @since 0.0.0
  */
-export const orElse = <W2, A2>({
-  orElseWarnings,
-  orElseSuccess,
-}: {
-  orElseWarnings: () => W2;
-  orElseSuccess: () => A2;
-}): (<W, A>(
-  warnResult: WarnResult<W, A>,
-) => SuccessWithWarnings<W | W2, A | A2>) =>
-  match({
-    WarningsOnly: ({ warnings }) =>
-      SuccessWithWarnings({ warnings, success: orElseSuccess() }),
-    SuccessOnly: ({ success }) =>
-      SuccessWithWarnings({ warnings: orElseWarnings(), success }),
-    SuccessWithWarnings: ({ warnings, success }) =>
-      SuccessWithWarnings({ warnings, success }),
-  });
+export const orElse =
+  <A2, W2>({
+    orElseWarnings,
+    orElseSuccess,
+  }: {
+    orElseWarnings: () => W2;
+    orElseSuccess: () => A2;
+  }): (<A, W>(
+    warnResult: WarnResult<A, W>,
+  ) => SuccessWithWarnings<A | A2, W | W2>) =>
+  <A, W>(warnResult: WarnResult<A, W>): SuccessWithWarnings<A | A2, W | W2> =>
+    fromInclusiveOr(
+      InclusiveOr.orElse({
+        orElseLeft: orElseWarnings,
+        orElseRight: orElseSuccess,
+      })(toInclusiveOr(warnResult)),
+    );
 
 /**
  * Completes a `WarnResult` into a `SuccessWithWarnings` whose missing side is
@@ -680,15 +706,8 @@ export const orUndefined = orElse({
  */
 export const warningsOrElse =
   <Z>(orElseReturn: () => Z) =>
-  <W, A>(warnResult: WarnResult<W, A>): W | Z =>
-    pipe(
-      warnResult,
-      orElse({
-        orElseWarnings: orElseReturn,
-        orElseSuccess: constUndefined,
-      }),
-      Struct.get("warnings"),
-    );
+  <A, W>(warnResult: WarnResult<A, W>): W | Z =>
+    InclusiveOr.leftOrElse(orElseReturn)(toInclusiveOr(warnResult));
 
 /**
  * Extracts the `warnings` of a `WarnResult`, returning `undefined` when no
@@ -745,15 +764,8 @@ export const warningsOrUndefined = warningsOrElse(() => undefined);
  */
 export const successOrElse =
   <Z>(orElseReturn: () => Z) =>
-  <W, A>(warnResult: WarnResult<W, A>): A | Z =>
-    pipe(
-      warnResult,
-      orElse({
-        orElseWarnings: constUndefined,
-        orElseSuccess: orElseReturn,
-      }),
-      Struct.get("success"),
-    );
+  <A, W>(warnResult: WarnResult<A, W>): A | Z =>
+    InclusiveOr.rightOrElse(orElseReturn)(toInclusiveOr(warnResult));
 
 /**
  * Extracts the `success` value of a `WarnResult`, returning `undefined` when no
@@ -807,16 +819,9 @@ export const successOrUndefined = successOrElse(() => undefined);
  * @category getters
  * @since 0.0.0
  */
-export const successOption = <W, A>(
-  warnResult: WarnResult<W, A>,
-): Option.Option<A> =>
-  pipe(
-    warnResult,
-    matchSuccess({
-      WarningsOnly: () => Option.none(),
-      Success: Option.some,
-    }),
-  );
+export const successOption = <A, W>(
+  warnResult: WarnResult<A, W>,
+): Option.Option<A> => InclusiveOr.rightOption(toInclusiveOr(warnResult));
 
 /**
  * Extracts the `warnings` of a `WarnResult` as an `Option`.
@@ -842,16 +847,9 @@ export const successOption = <W, A>(
  * @category getters
  * @since 0.0.0
  */
-export const warningsOption = <W, A>(
-  warnResult: WarnResult<W, A>,
-): Option.Option<W> =>
-  pipe(
-    warnResult,
-    matchWarnings({
-      Warnings: Option.some,
-      SuccessOnly: () => Option.none(),
-    }),
-  );
+export const warningsOption = <A, W>(
+  warnResult: WarnResult<A, W>,
+): Option.Option<W> => InclusiveOr.leftOption(toInclusiveOr(warnResult));
 
 /**
  * Transforms both sides of a `WarnResult`, applying `mapWarnings` to any
@@ -884,23 +882,20 @@ export const warningsOption = <W, A>(
  * @category mapping
  * @since 0.0.0
  */
-export const mapBoth = <W1, A1, W2, A2>({
-  mapWarnings,
-  mapSuccess,
-}: {
-  mapWarnings: (warnings: W1) => W2;
-  mapSuccess: (success: A1) => A2;
-}): ((warnResult: WarnResult<W1, A1>) => WarnResult<W2, A2>) =>
-  match({
-    WarningsOnly: ({ warnings }) =>
-      WarningsOnly({ warnings: mapWarnings(warnings) }),
-    SuccessOnly: ({ success }) => SuccessOnly({ success: mapSuccess(success) }),
-    SuccessWithWarnings: ({ warnings, success }) =>
-      SuccessWithWarnings({
-        warnings: mapWarnings(warnings),
-        success: mapSuccess(success),
-      }),
-  });
+export const mapBoth =
+  <A1, W1, A2, W2>({
+    mapWarnings,
+    mapSuccess,
+  }: {
+    mapWarnings: (warnings: W1) => W2;
+    mapSuccess: (success: A1) => A2;
+  }): ((warnResult: WarnResult<A1, W1>) => WarnResult<A2, W2>) =>
+  (warnResult) =>
+    fromInclusiveOr(
+      InclusiveOr.mapBoth({ mapLeft: mapWarnings, mapRight: mapSuccess })(
+        toInclusiveOr(warnResult),
+      ),
+    );
 
 /**
  * Effectful `mapBoth`: transforms each present side through an `Effect`,
@@ -932,39 +927,22 @@ export const mapBoth = <W1, A1, W2, A2>({
  * @category sequencing
  * @since 0.0.0
  */
-export const mapBothEffect = <W1, A1, W2, A2, EW, EA, RW, RA>({
-  mapWarnings,
-  mapSuccess,
-}: {
-  mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>;
-  mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>;
-}): ((
-  warnResult: WarnResult<W1, A1>,
-) => Effect.Effect<WarnResult<W2, A2>, EW | EA, RW | RA>) =>
-  match({
-    WarningsOnly: ({ warnings }) =>
-      pipe(
-        mapWarnings(warnings),
-        Effect.map((warnings2) => WarningsOnly({ warnings: warnings2 })),
-      ),
-
-    SuccessOnly: ({ success }) =>
-      pipe(
-        mapSuccess(success),
-        Effect.map((success2) => SuccessOnly({ success: success2 })),
-      ),
-
-    SuccessWithWarnings: ({ warnings, success }) =>
-      pipe(
-        Effect.all({
-          warnings: mapWarnings(warnings),
-          success: mapSuccess(success),
-        }),
-        Effect.map(({ warnings: warnings2, success: success2 }) =>
-          SuccessWithWarnings({ warnings: warnings2, success: success2 }),
-        ),
-      ),
-  });
+export const mapBothEffect =
+  <A1, W1, A2, W2, EA, EW, RA, RW>({
+    mapWarnings,
+    mapSuccess,
+  }: {
+    mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>;
+    mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>;
+  }): ((
+    warnResult: WarnResult<A1, W1>,
+  ) => Effect.Effect<WarnResult<A2, W2>, EW | EA, RW | RA>) =>
+  (warnResult) =>
+    pipe(
+      toInclusiveOr(warnResult),
+      InclusiveOr.mapBothEffect({ mapLeft: mapWarnings, mapRight: mapSuccess }),
+      Effect.map((io) => fromInclusiveOr(io)),
+    );
 
 /**
  * Transforms the `warnings` of a `WarnResult`, leaving any `success` value
@@ -995,10 +973,14 @@ export const mapBothEffect = <W1, A1, W2, A2, EW, EA, RW, RA>({
  * @category mapping
  * @since 0.0.0
  */
-export const mapWarnings = <W1, W2>(
-  mapWarnings: (warnings: W1) => W2,
-): (<A>(warnResult: WarnResult<W1, A>) => WarnResult<W2, A>) =>
-  mapBoth({ mapWarnings, mapSuccess: identity });
+export const mapWarnings =
+  <W1, W2>(
+    mapWarnings: (warnings: W1) => W2,
+  ): (<A>(warnResult: WarnResult<A, W1>) => WarnResult<A, W2>) =>
+  (warnResult) =>
+    fromInclusiveOr(
+      InclusiveOr.mapLeft(mapWarnings)(toInclusiveOr(warnResult)),
+    );
 
 /**
  * Chains the `warnings` of a `WarnResult` into a new `WarnResult`, flattening the
@@ -1032,14 +1014,16 @@ export const mapWarnings = <W1, W2>(
  * @category sequencing
  * @since 0.0.0
  */
-export const flatMapWarnings = <W1, W2, A2>(
-  mapWarnings: (warnings: W1) => WarnResult<W2, A2>,
-): (<A1>(warnResult: WarnResult<W1, A1>) => WarnResult<W2, A1 | A2>) =>
-  match({
-    WarningsOnly: ({ warnings }) => mapWarnings(warnings),
-    SuccessOnly: ({ success }) => SuccessOnly({ success }),
-    SuccessWithWarnings: ({ warnings }) => mapWarnings(warnings),
-  });
+export const flatMapWarnings =
+  <A2, W1, W2>(
+    mapWarnings: (warnings: W1) => WarnResult<A2, W2>,
+  ): (<A1>(warnResult: WarnResult<A1, W1>) => WarnResult<A1 | A2, W2>) =>
+  (warnResult) =>
+    fromInclusiveOr(
+      InclusiveOr.flatMapLeft((warnings: W1) =>
+        toInclusiveOr(mapWarnings(warnings)),
+      )(toInclusiveOr(warnResult)),
+    );
 
 /**
  * Effectful `mapWarnings`: transforms the `warnings` of a `WarnResult` through an
@@ -1069,12 +1053,18 @@ export const flatMapWarnings = <W1, W2, A2>(
  * @category sequencing
  * @since 0.0.0
  */
-export const mapWarningsEffect = <W1, W2, EW, RW>(
-  mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>,
-): (<A>(
-  warnResult: WarnResult<W1, A>,
-) => Effect.Effect<WarnResult<W2, A>, EW, RW>) =>
-  mapBothEffect({ mapWarnings, mapSuccess: Effect.succeed });
+export const mapWarningsEffect =
+  <W1, W2, EW, RW>(
+    mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>,
+  ): (<A>(
+    warnResult: WarnResult<A, W1>,
+  ) => Effect.Effect<WarnResult<A, W2>, EW, RW>) =>
+  (warnResult) =>
+    pipe(
+      toInclusiveOr(warnResult),
+      InclusiveOr.mapLeftEffect(mapWarnings),
+      Effect.map((io) => fromInclusiveOr(io)),
+    );
 
 /**
  * Effectful `flatMapWarnings`: chains the `warnings` of a `WarnResult` into an
@@ -1107,16 +1097,20 @@ export const mapWarningsEffect = <W1, W2, EW, RW>(
  * @category sequencing
  * @since 0.0.0
  */
-export const flatMapWarningsEffect = <W1, W2, A2, EW, RW>(
-  mapWarnings: (warnings: W1) => Effect.Effect<WarnResult<W2, A2>, EW, RW>,
-): (<A1>(
-  warnResult: WarnResult<W1, A1>,
-) => Effect.Effect<WarnResult<W2, A1 | A2>, EW, RW>) =>
-  match({
-    WarningsOnly: ({ warnings }) => mapWarnings(warnings),
-    SuccessOnly: ({ success }) => Effect.succeed(SuccessOnly({ success })),
-    SuccessWithWarnings: ({ warnings }) => mapWarnings(warnings),
-  });
+export const flatMapWarningsEffect =
+  <A2, W1, W2, EW, RW>(
+    mapWarnings: (warnings: W1) => Effect.Effect<WarnResult<A2, W2>, EW, RW>,
+  ): (<A1>(
+    warnResult: WarnResult<A1, W1>,
+  ) => Effect.Effect<WarnResult<A1 | A2, W2>, EW, RW>) =>
+  (warnResult) =>
+    pipe(
+      toInclusiveOr(warnResult),
+      InclusiveOr.flatMapLeftEffect((warnings: W1) =>
+        Effect.map(mapWarnings(warnings), toInclusiveOr),
+      ),
+      Effect.map((io) => fromInclusiveOr(io)),
+    );
 
 /**
  * Transforms the `success` value of a `WarnResult`, leaving any `warnings`
@@ -1144,10 +1138,14 @@ export const flatMapWarningsEffect = <W1, W2, A2, EW, RW>(
  * @category mapping
  * @since 0.0.0
  */
-export const mapSuccess = <A1, A2>(
-  mapSuccess: (success: A1) => A2,
-): (<W>(warnResult: WarnResult<W, A1>) => WarnResult<W, A2>) =>
-  mapBoth({ mapWarnings: identity, mapSuccess });
+export const mapSuccess =
+  <A1, A2>(
+    mapSuccess: (success: A1) => A2,
+  ): (<W>(warnResult: WarnResult<A1, W>) => WarnResult<A2, W>) =>
+  (warnResult) =>
+    fromInclusiveOr(
+      InclusiveOr.mapRight(mapSuccess)(toInclusiveOr(warnResult)),
+    );
 
 /**
  * Chains the `success` value of a `WarnResult` into a new `WarnResult`, flattening
@@ -1179,14 +1177,16 @@ export const mapSuccess = <A1, A2>(
  * @category sequencing
  * @since 0.0.0
  */
-export const flatMapSuccess = <W2, A1, A2>(
-  mapSuccess: (success: A1) => WarnResult<W2, A2>,
-): (<W1>(warnResult: WarnResult<W1, A1>) => WarnResult<W1 | W2, A2>) =>
-  match({
-    WarningsOnly: ({ warnings }) => WarningsOnly({ warnings }),
-    SuccessOnly: ({ success }) => mapSuccess(success),
-    SuccessWithWarnings: ({ success }) => mapSuccess(success),
-  });
+export const flatMapSuccess =
+  <A1, A2, W2>(
+    mapSuccess: (success: A1) => WarnResult<A2, W2>,
+  ): (<W1>(warnResult: WarnResult<A1, W1>) => WarnResult<A2, W1 | W2>) =>
+  (warnResult) =>
+    fromInclusiveOr(
+      InclusiveOr.flatMapRight((success: A1) =>
+        toInclusiveOr(mapSuccess(success)),
+      )(toInclusiveOr(warnResult)),
+    );
 
 /**
  * Effectful `mapSuccess`: transforms the `success` value of a `WarnResult` through
@@ -1216,12 +1216,18 @@ export const flatMapSuccess = <W2, A1, A2>(
  * @category sequencing
  * @since 0.0.0
  */
-export const mapSuccessEffect = <A1, A2, EA, RA>(
-  mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>,
-): (<W>(
-  warnResult: WarnResult<W, A1>,
-) => Effect.Effect<WarnResult<W, A2>, EA, RA>) =>
-  mapBothEffect({ mapWarnings: Effect.succeed, mapSuccess });
+export const mapSuccessEffect =
+  <A1, A2, EA, RA>(
+    mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>,
+  ): (<W>(
+    warnResult: WarnResult<A1, W>,
+  ) => Effect.Effect<WarnResult<A2, W>, EA, RA>) =>
+  (warnResult) =>
+    pipe(
+      toInclusiveOr(warnResult),
+      InclusiveOr.mapRightEffect(mapSuccess),
+      Effect.map((io) => fromInclusiveOr(io)),
+    );
 
 /**
  * Effectful `flatMapSuccess`: chains the `success` value of a `WarnResult` into an
@@ -1253,13 +1259,77 @@ export const mapSuccessEffect = <A1, A2, EA, RA>(
  * @category sequencing
  * @since 0.0.0
  */
-export const flatMapSuccessEffect = <W2, A1, A2, EA, RA>(
-  mapSuccess: (success: A1) => Effect.Effect<WarnResult<W2, A2>, EA, RA>,
-): (<W1>(
-  warnResult: WarnResult<W1, A1>,
-) => Effect.Effect<WarnResult<W1 | W2, A2>, EA, RA>) =>
-  match({
-    WarningsOnly: ({ warnings }) => Effect.succeed(WarningsOnly({ warnings })),
-    SuccessOnly: ({ success }) => mapSuccess(success),
-    SuccessWithWarnings: ({ success }) => mapSuccess(success),
-  });
+export const flatMapSuccessEffect =
+  <A1, A2, W2, EA, RA>(
+    mapSuccess: (success: A1) => Effect.Effect<WarnResult<A2, W2>, EA, RA>,
+  ): (<W1>(
+    warnResult: WarnResult<A1, W1>,
+  ) => Effect.Effect<WarnResult<A2, W1 | W2>, EA, RA>) =>
+  (warnResult) =>
+    pipe(
+      toInclusiveOr(warnResult),
+      InclusiveOr.flatMapRightEffect((success: A1) =>
+        Effect.map(mapSuccess(success), toInclusiveOr),
+      ),
+      Effect.map((io) => fromInclusiveOr(io)),
+    );
+
+/**
+ * Zips two arrays into one, calling `f` with a `WarnResult` for each index so
+ * that length mismatches are handled explicitly rather than truncated.
+ *
+ * Unlike `Array.zipWith` (which stops at the shorter array), this walks to the
+ * length of the *longer* array. The first array's element fills the `warnings`
+ * side and the second array's element fills the `success` side, so at each index
+ * `f` receives a `WarnResult.WarnResult<B, A>`: `SuccessWithWarnings` when both
+ * arrays have an element, `WarningsOnly` when only the first does, and
+ * `SuccessOnly` when only the second does. Use it when the "extra" tail of either
+ * array still carries meaning.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`
+ * })
+ *
+ * // data-first
+ * assert.deepStrictEqual(WarnResult.zip([1, 2, 3], [10, 20], describe), [
+ *   "both 1/10",
+ *   "both 2/20",
+ *   "warnings 3"
+ * ])
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(pipe([1, 2, 3], WarnResult.zip([10, 20], describe)), [
+ *   "both 1/10",
+ *   "both 2/20",
+ *   "warnings 3"
+ * ])
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const zip: {
+  <A, B, C>(
+    array2: readonly B[],
+    f: (warnResult: WarnResult<B, A>) => C,
+  ): (array1: readonly A[]) => C[];
+  <A, B, C>(
+    array1: readonly A[],
+    array2: readonly B[],
+    f: (warnResult: WarnResult<B, A>) => C,
+  ): C[];
+} = dual(
+  3,
+  <A, B, C>(
+    array1: readonly A[],
+    array2: readonly B[],
+    f: (warnResult: WarnResult<B, A>) => C,
+  ): C[] => InclusiveOr.zip(array1, array2, (io) => f(fromInclusiveOr(io))),
+);