@nunofyobiz/effect-extras 0.0.2 → 2.0.0

package/dist/index.d.ts

@@ -2,184 +2,202 @@ import { Data, Effect, Option, Equivalence, Array, Predicate, Order, DateTime, D
 import * as effect_Unify from 'effect/Unify';
 
 /**
- * A value carrying a left `L`, a right `R`, or both at once — the data type for
- * an "inclusive or".
+ * A result that may come with a success value and may come with warnings — both
+ * are optional, but never both absent.
  *
- * Where `Result<R, L>` models an exclusive choice (success _or_ failure),
- * `These` adds the third case where both sides are present. It is a tagged enum
- * with three constructors: `LeftOnly` (only `left`), `RightOnly` (only `right`),
- * and `LeftAndRight` (both). Reach for it when an operation can produce partial
- * results — e.g. a parse that yields a value _and_ a list of warnings.
+ * Where `Result<A, E>` models an exclusive choice (success _or_ failure),
+ * `WarnResult` is an "inclusive or": the success value and the warnings can each
+ * be present independently. It is a tagged enum with three constructors:
+ * `SuccessOnly` (only a `success` value), `WarningsOnly` (only `warnings`), and
+ * `SuccessWithWarnings` (both). Reach for it when an operation can succeed, warn,
+ * or do both at once — e.g. a parse that yields a value _and_ a list of warnings,
+ * or that only produces warnings.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const both: These.These<number, string> = These.LeftAndRight({
- *   left: 1,
- *   right: "a"
- * })
+ * const both: WarnResult.WarnResult<string, number> =
+ *   WarnResult.SuccessWithWarnings({
+ *     warnings: "rounded down",
+ *     success: 1
+ *   })
  *
- * assert.deepStrictEqual(both._tag, "LeftAndRight")
+ * assert.deepStrictEqual(both._tag, "SuccessWithWarnings")
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type These<L, R> = Data.TaggedEnum<{
-    LeftOnly: {
-        readonly left: L;
+type WarnResult<W, A> = Data.TaggedEnum<{
+    WarningsOnly: {
+        readonly warnings: W;
     };
-    RightOnly: {
-        readonly right: R;
+    SuccessOnly: {
+        readonly success: A;
     };
-    LeftAndRight: {
-        readonly left: L;
-        readonly right: R;
+    SuccessWithWarnings: {
+        readonly warnings: W;
+        readonly success: A;
     };
 }>;
 /**
- * The `LeftOnly` member of `These` — a value that carries only a `left` and no
- * `right`.
+ * The `WarningsOnly` member of `WarnResult` — a result that carries only
+ * `warnings` and no `success` value.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: These.LeftOnly<number> = These.LeftOnly({ left: 1 })
+ * const value: WarnResult.WarningsOnly<string> = WarnResult.WarningsOnly({
+ *   warnings: "skipped 2 rows"
+ * })
  *
- * assert.deepStrictEqual(value.left, 1)
+ * assert.deepStrictEqual(value.warnings, "skipped 2 rows")
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type LeftOnly<L> = These<L, never> & {
-    _tag: "LeftOnly";
+type WarningsOnly<W> = WarnResult<W, never> & {
+    _tag: "WarningsOnly";
 };
 /**
- * Constructs a `LeftOnly` — a `These` that carries only a `left`.
+ * Constructs a `WarningsOnly` — a `WarnResult` that carries only `warnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value = These.LeftOnly({ left: 1 })
+ * const value = WarnResult.WarningsOnly({ warnings: "skipped 2 rows" })
  *
- * assert.deepStrictEqual(value._tag, "LeftOnly")
- * assert.deepStrictEqual(value.left, 1)
+ * assert.deepStrictEqual(value._tag, "WarningsOnly")
+ * assert.deepStrictEqual(value.warnings, "skipped 2 rows")
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const LeftOnly: <A, B>(args: {
-    readonly left: A;
+declare const WarningsOnly: <A, B>(args: {
+    readonly warnings: A;
 }) => {
-    readonly _tag: "LeftOnly";
-    readonly left: A;
+    readonly _tag: "WarningsOnly";
+    readonly warnings: A;
 };
 /**
- * The `RightOnly` member of `These` — a value that carries only a `right` and no
- * `left`.
+ * The `SuccessOnly` member of `WarnResult` — a result that carries only a
+ * `success` value and no `warnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: These.RightOnly<string> = These.RightOnly({ right: "a" })
+ * const value: WarnResult.SuccessOnly<number> = WarnResult.SuccessOnly({
+ *   success: 1
+ * })
  *
- * assert.deepStrictEqual(value.right, "a")
+ * assert.deepStrictEqual(value.success, 1)
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type RightOnly<R> = These<never, R> & {
-    _tag: "RightOnly";
+type SuccessOnly<A> = WarnResult<never, A> & {
+    _tag: "SuccessOnly";
 };
 /**
- * Constructs a `RightOnly` — a `These` that carries only a `right`.
+ * Constructs a `SuccessOnly` — a `WarnResult` that carries only a `success` value.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value = These.RightOnly({ right: "a" })
+ * const value = WarnResult.SuccessOnly({ success: 1 })
  *
- * assert.deepStrictEqual(value._tag, "RightOnly")
- * assert.deepStrictEqual(value.right, "a")
+ * assert.deepStrictEqual(value._tag, "SuccessOnly")
+ * assert.deepStrictEqual(value.success, 1)
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const RightOnly: <A, B>(args: {
-    readonly right: B;
+declare const SuccessOnly: <A, B>(args: {
+    readonly success: B;
 }) => {
-    readonly _tag: "RightOnly";
-    readonly right: B;
+    readonly _tag: "SuccessOnly";
+    readonly success: B;
 };
 /**
- * The `LeftAndRight` member of `These` — a value that carries both a `left` and a
- * `right`.
+ * The `SuccessWithWarnings` member of `WarnResult` — a result that carries both a
+ * `success` value and `warnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: These.LeftAndRight<number, string> = These.LeftAndRight({
- *   left: 1,
- *   right: "a"
- * })
+ * const value: WarnResult.SuccessWithWarnings<string, number> =
+ *   WarnResult.SuccessWithWarnings({
+ *     warnings: "rounded down",
+ *     success: 1
+ *   })
  *
- * assert.deepStrictEqual(value, { _tag: "LeftAndRight", left: 1, right: "a" })
+ * assert.deepStrictEqual(value, {
+ *   _tag: "SuccessWithWarnings",
+ *   warnings: "rounded down",
+ *   success: 1
+ * })
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type LeftAndRight<L, R> = These<L, R> & {
-    _tag: "LeftAndRight";
+type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
+    _tag: "SuccessWithWarnings";
 };
 /**
- * Constructs a `LeftAndRight` — a `These` that carries both a `left` and a
- * `right`.
+ * Constructs a `SuccessWithWarnings` — a `WarnResult` that carries both a
+ * `success` value and `warnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value = These.LeftAndRight({ left: 1, right: "a" })
+ * const value = WarnResult.SuccessWithWarnings({
+ *   warnings: "rounded down",
+ *   success: 1
+ * })
  *
- * assert.deepStrictEqual(value._tag, "LeftAndRight")
- * assert.deepStrictEqual(value.left, 1)
- * assert.deepStrictEqual(value.right, "a")
+ * assert.deepStrictEqual(value._tag, "SuccessWithWarnings")
+ * assert.deepStrictEqual(value.warnings, "rounded down")
+ * assert.deepStrictEqual(value.success, 1)
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const LeftAndRight: <A, B>(args: {
-    readonly left: A;
-    readonly right: B;
+declare const SuccessWithWarnings: <A, B>(args: {
+    readonly warnings: A;
+    readonly success: B;
 }) => {
-    readonly _tag: "LeftAndRight";
-    readonly left: A;
-    readonly right: B;
+    readonly _tag: "SuccessWithWarnings";
+    readonly warnings: A;
+    readonly success: B;
 };
 /**
- * Builds per-tag refinements for `These`. `is("LeftOnly")` is a type guard that
- * narrows a `These` to its `LeftOnly` member, and likewise for `"RightOnly"` and
- * `"LeftAndRight"`.
+ * Builds per-tag refinements for `WarnResult`. `is("WarningsOnly")` is a type
+ * guard that narrows a `WarnResult` to its `WarningsOnly` member, and likewise for
+ * `"SuccessOnly"` and `"SuccessWithWarnings"`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * assert.deepStrictEqual(These.is("LeftOnly")(These.LeftOnly({ left: 1 })), true)
  * assert.deepStrictEqual(
- *   These.is("LeftOnly")(These.RightOnly({ right: "a" })),
+ *   WarnResult.is("WarningsOnly")(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   true
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.is("WarningsOnly")(WarnResult.SuccessOnly({ success: 1 })),
  *   false
  * )
  * ```
@@ -187,56 +205,56 @@ declare const LeftAndRight: <A, B>(args: {
  * @category guards
  * @since 0.0.0
  */
-declare const is: <Tag extends "LeftOnly" | "RightOnly" | "LeftAndRight">(tag: Tag) => {
+declare const is: <Tag extends "WarningsOnly" | "SuccessOnly" | "SuccessWithWarnings">(tag: Tag) => {
     <T extends {
-        readonly _tag: "LeftOnly";
-        readonly left: any;
+        readonly _tag: "WarningsOnly";
+        readonly warnings: any;
     } | {
-        readonly _tag: "RightOnly";
-        readonly right: any;
+        readonly _tag: "SuccessOnly";
+        readonly success: any;
     } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: any;
-        readonly right: any;
+        readonly _tag: "SuccessWithWarnings";
+        readonly warnings: any;
+        readonly success: any;
     }>(u: T): u is T & {
         readonly _tag: Tag;
     };
     (u: unknown): u is Extract<{
-        readonly _tag: "LeftOnly";
-        readonly left: unknown;
+        readonly _tag: "WarningsOnly";
+        readonly warnings: unknown;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
-        readonly _tag: "RightOnly";
-        readonly right: unknown;
+        readonly _tag: "SuccessOnly";
+        readonly success: unknown;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
-        readonly _tag: "LeftAndRight";
-        readonly left: unknown;
-        readonly right: unknown;
+        readonly _tag: "SuccessWithWarnings";
+        readonly warnings: unknown;
+        readonly success: unknown;
     }, {
         readonly _tag: Tag;
     }>;
 };
 /**
- * Folds a `These` over its three tags. Provide a handler for `LeftOnly`,
- * `RightOnly`, and `LeftAndRight` and `match` returns a function from a `These`
- * to the handlers' common result type.
+ * Folds a `WarnResult` over its three tags. Provide a handler for `WarningsOnly`,
+ * `SuccessOnly`, and `SuccessWithWarnings` and `match` returns a function from a
+ * `WarnResult` to the handlers' common result type.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const describe = These.match({
- *   LeftOnly: ({ left }) => `left ${left}`,
- *   RightOnly: ({ right }) => `right ${right}`,
- *   LeftAndRight: ({ left, right }) => `both ${left}/${right}`
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`
  * })
  *
  * assert.deepStrictEqual(
- *   describe(These.LeftAndRight({ left: 1, right: "a" })),
- *   "both 1/a"
+ *   describe(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   "both w/1"
  * )
  * ```
  *
@@ -245,178 +263,184 @@ declare const is: <Tag extends "LeftOnly" | "RightOnly" | "LeftAndRight">(tag: T
  */
 declare const match$1: {
     <A, B, C, D, Cases extends {
-        readonly LeftOnly: (args: {
-            readonly _tag: "LeftOnly";
-            readonly left: A;
+        readonly WarningsOnly: (args: {
+            readonly _tag: "WarningsOnly";
+            readonly warnings: A;
         }) => any;
-        readonly RightOnly: (args: {
-            readonly _tag: "RightOnly";
-            readonly right: B;
+        readonly SuccessOnly: (args: {
+            readonly _tag: "SuccessOnly";
+            readonly success: B;
         }) => any;
-        readonly LeftAndRight: (args: {
-            readonly _tag: "LeftAndRight";
-            readonly left: A;
-            readonly right: B;
+        readonly SuccessWithWarnings: (args: {
+            readonly _tag: "SuccessWithWarnings";
+            readonly warnings: A;
+            readonly success: B;
         }) => any;
     }>(cases: Cases): (self: {
-        readonly _tag: "LeftOnly";
-        readonly left: A;
+        readonly _tag: "WarningsOnly";
+        readonly warnings: A;
     } | {
-        readonly _tag: "RightOnly";
-        readonly right: B;
+        readonly _tag: "SuccessOnly";
+        readonly success: B;
     } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: A;
-        readonly right: B;
-    }) => effect_Unify.Unify<ReturnType<Cases["LeftOnly" | "RightOnly" | "LeftAndRight"]>>;
+        readonly _tag: "SuccessWithWarnings";
+        readonly warnings: A;
+        readonly success: B;
+    }) => effect_Unify.Unify<ReturnType<Cases["WarningsOnly" | "SuccessOnly" | "SuccessWithWarnings"]>>;
     <A, B, C, D, Cases extends {
-        readonly LeftOnly: (args: {
-            readonly _tag: "LeftOnly";
-            readonly left: A;
+        readonly WarningsOnly: (args: {
+            readonly _tag: "WarningsOnly";
+            readonly warnings: A;
         }) => any;
-        readonly RightOnly: (args: {
-            readonly _tag: "RightOnly";
-            readonly right: B;
+        readonly SuccessOnly: (args: {
+            readonly _tag: "SuccessOnly";
+            readonly success: B;
         }) => any;
-        readonly LeftAndRight: (args: {
-            readonly _tag: "LeftAndRight";
-            readonly left: A;
-            readonly right: B;
+        readonly SuccessWithWarnings: (args: {
+            readonly _tag: "SuccessWithWarnings";
+            readonly warnings: A;
+            readonly success: B;
         }) => any;
     }>(self: {
-        readonly _tag: "LeftOnly";
-        readonly left: A;
+        readonly _tag: "WarningsOnly";
+        readonly warnings: A;
     } | {
-        readonly _tag: "RightOnly";
-        readonly right: B;
+        readonly _tag: "SuccessOnly";
+        readonly success: B;
     } | {
-        readonly _tag: "LeftAndRight";
-        readonly left: A;
-        readonly right: B;
-    }, cases: Cases): effect_Unify.Unify<ReturnType<Cases["LeftOnly" | "RightOnly" | "LeftAndRight"]>>;
+        readonly _tag: "SuccessWithWarnings";
+        readonly warnings: A;
+        readonly success: B;
+    }, cases: Cases): effect_Unify.Unify<ReturnType<Cases["WarningsOnly" | "SuccessOnly" | "SuccessWithWarnings"]>>;
 };
 /**
- * Any `These` that is guaranteed to carry a `left` — either `LeftOnly` or
- * `LeftAndRight`.
+ * Any `WarnResult` that is guaranteed to carry `warnings` — either `WarningsOnly`
+ * or `SuccessWithWarnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: These.WithLeft<number, string> = These.LeftOnly({ left: 1 })
+ * const value: WarnResult.WithWarnings<string, number> = WarnResult.WarningsOnly({
+ *   warnings: "skipped 2 rows"
+ * })
  *
- * assert.deepStrictEqual(value.left, 1)
+ * assert.deepStrictEqual(value.warnings, "skipped 2 rows")
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type WithLeft<L, R> = LeftOnly<L> | LeftAndRight<L, R>;
+type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
 /**
- * Builds a `These` known to carry a `left`, choosing `LeftAndRight` when `right`
- * is present and `LeftOnly` otherwise.
+ * Builds a `WarnResult` known to carry `warnings`, choosing `SuccessWithWarnings`
+ * when a `success` value is present and `WarningsOnly` otherwise.
  *
- * Use it when the `left` is mandatory and the `right` is an optional companion:
- * pass an absent (`null`/`undefined`) `right` to get a `LeftOnly`, or a present
- * one to get a `LeftAndRight`. The return type `WithLeft<L, R>` reflects that a
- * `left` is always present.
+ * 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.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
  * assert.deepStrictEqual(
- *   These.WithLeft({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
+ *   WarnResult.WithWarnings({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
  * )
  *
  * assert.deepStrictEqual(
- *   These.WithLeft({ left: 1 }),
- *   These.LeftOnly({ left: 1 })
+ *   WarnResult.WithWarnings({ warnings: "w" }),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
  * )
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const WithLeft: <L, R>({ left, right, }: {
-    left: L;
-    right?: R | undefined;
-}) => WithLeft<L, R>;
+declare const WithWarnings: <W, A>({ warnings, success, }: {
+    warnings: W;
+    success?: A | undefined;
+}) => WithWarnings<W, A>;
 /**
- * Any `These` that is guaranteed to carry a `right` — either `RightOnly` or
- * `LeftAndRight`.
+ * Any `WarnResult` that is guaranteed to carry a `success` value — either
+ * `SuccessOnly` or `SuccessWithWarnings`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: These.WithRight<number, string> = These.RightOnly({ right: "a" })
+ * const value: WarnResult.WithSuccess<string, number> = WarnResult.SuccessOnly({
+ *   success: 1
+ * })
  *
- * assert.deepStrictEqual(value.right, "a")
+ * assert.deepStrictEqual(value.success, 1)
  * ```
  *
  * @category models
  * @since 0.0.0
  */
-type WithRight<L, R> = RightOnly<R> | LeftAndRight<L, R>;
+type WithSuccess<W, A> = SuccessOnly<A> | SuccessWithWarnings<W, A>;
 /**
- * Builds a `These` known to carry a `right`, choosing `LeftAndRight` when `left`
- * is present and `RightOnly` otherwise.
+ * Builds a `WarnResult` known to carry a `success` value, choosing
+ * `SuccessWithWarnings` when `warnings` are present and `SuccessOnly` otherwise.
  *
- * The mirror of `WithLeft`: the `right` is mandatory and the `left` is an
- * optional companion. Pass an absent (`null`/`undefined`) `left` to get a
- * `RightOnly`, or a present one to get a `LeftAndRight`. The return type
- * `WithRight<L, R>` reflects that a `right` is always present.
+ * 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
+ * `success` value is always present.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
  * assert.deepStrictEqual(
- *   These.WithRight({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
+ *   WarnResult.WithSuccess({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
  * )
  *
  * assert.deepStrictEqual(
- *   These.WithRight({ right: "a" }),
- *   These.RightOnly({ right: "a" })
+ *   WarnResult.WithSuccess({ success: 1 }),
+ *   WarnResult.SuccessOnly({ success: 1 })
  * )
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const WithRight: <L, R>({ left, right, }: {
-    left?: L | undefined;
-    right: R;
-}) => WithRight<L, R>;
+declare const WithSuccess: <W, A>({ warnings, success, }: {
+    warnings?: W | undefined;
+    success: A;
+}) => WithSuccess<W, A>;
 /**
- * Builds a `These` from a pair of possibly-nullish inputs, wrapping the result in
- * an `Option` so the all-absent case is expressible.
+ * Builds a `WarnResult` from a pair of possibly-nullish inputs, wrapping the
+ * result in an `Option` so the all-absent case is expressible.
  *
- * Returns `Option.some(LeftAndRight)` when both are present, `Option.some(LeftOnly)`
- * or `Option.some(RightOnly)` when exactly one is present, and `Option.none()`
- * when both are nullish. Use it as the total entry point for turning two optional
- * values into a `These`.
+ * Returns `Option.some(SuccessWithWarnings)` when both are present,
+ * `Option.some(WarningsOnly)` or `Option.some(SuccessOnly)` when exactly one is
+ * present, and `Option.none()` when both are nullish. Use it as the total entry
+ * point for turning an optional success value and optional warnings into a
+ * `WarnResult`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: 1, right: "a" }),
- *   Option.some(These.LeftAndRight({ left: 1, right: "a" }))
+ *   WarnResult.optionFromNullables({ warnings: "w", success: 1 }),
+ *   Option.some(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
  * )
  *
  * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: 1, right: null }),
- *   Option.some(These.LeftOnly({ left: 1 }))
+ *   WarnResult.optionFromNullables({ warnings: "w", success: null }),
+ *   Option.some(WarnResult.WarningsOnly({ warnings: "w" }))
  * )
  *
  * assert.deepStrictEqual(
- *   These.optionFromNullables({ left: null, right: undefined }),
+ *   WarnResult.optionFromNullables({ warnings: null, success: undefined }),
  *   Option.none()
  * )
  * ```
@@ -424,13 +448,13 @@ declare const WithRight: <L, R>({ left, right, }: {
  * @category constructors
  * @since 0.0.0
  */
-declare const optionFromNullables: <L, R>({ left, right, }: {
-    left?: L | null | undefined;
-    right?: R | null | undefined;
-}) => Option.Option<These<L, R>>;
+declare const optionFromNullables: <W, A>({ warnings, success, }: {
+    warnings?: W | null | undefined;
+    success?: A | null | undefined;
+}) => Option.Option<WarnResult<W, A>>;
 /**
- * Builds a `These` from a pair of possibly-nullish inputs, falling back to the
- * `orElse` thunk when both are absent.
+ * Builds a `WarnResult` from a pair of possibly-nullish inputs, falling back to
+ * the `orElse` thunk when both are absent.
  *
  * The non-optional companion to `optionFromNullables`: it unwraps the same logic
  * but resolves the all-absent case with `orElse` instead of an `Option`. The
@@ -439,215 +463,239 @@ declare const optionFromNullables: <L, R>({ left, right, }: {
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
  * assert.deepStrictEqual(
- *   These.fromNullables({ left: 1, right: "a" }),
- *   These.LeftAndRight({ left: 1, right: "a" })
+ *   WarnResult.fromNullables({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
  * )
  *
  * // Both absent — fall back via orElse instead of throwing
  * assert.deepStrictEqual(
- *   These.fromNullables({
- *     left: null,
- *     right: null,
- *     orElse: () => These.LeftOnly({ left: 0 })
+ *   WarnResult.fromNullables({
+ *     warnings: null,
+ *     success: null,
+ *     orElse: () => WarnResult.WarningsOnly({ warnings: "none" })
  *   }),
- *   These.LeftOnly({ left: 0 })
+ *   WarnResult.WarningsOnly({ warnings: "none" })
  * )
  * ```
  *
  * @category constructors
  * @since 0.0.0
  */
-declare const fromNullables: <L, R>({ left, right, orElse, }: {
-    left?: L | null | undefined;
-    right?: R | null | undefined;
-    orElse?: () => These<L, R>;
-}) => These<L, R>;
+declare const fromNullables: <W, A>({ warnings, success, orElse, }: {
+    warnings?: W | null | undefined;
+    success?: A | null | undefined;
+    orElse?: () => WarnResult<W, A>;
+}) => WarnResult<W, A>;
 /**
- * Folds a `These` from the left's perspective, collapsing the three tags into two
- * handlers.
+ * Folds a `WarnResult` from the warnings' perspective, collapsing the three tags
+ * into two handlers.
  *
- * Both `LeftOnly` and `LeftAndRight` carry a `left`, so they route to the `Left`
- * handler; only `RightOnly` lacks a `left` and routes to `RightOnly`. Use it when
- * you care about the `left` value and treat the right-only case as the exception.
+ * Both `WarningsOnly` and `SuccessWithWarnings` carry `warnings`, so they route to
+ * the `Warnings` handler; only `SuccessOnly` lacks `warnings` and routes to
+ * `SuccessOnly`. Use it when you care about the `warnings` and treat the
+ * success-only case as the exception.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const onLeft = These.matchLeft({
- *   Left: (left: number) => `left ${left}`,
- *   RightOnly: (right: string) => `right ${right}`
+ * const onWarnings = WarnResult.matchWarnings({
+ *   Warnings: (warnings: string) => `warnings ${warnings}`,
+ *   SuccessOnly: (success: number) => `success ${success}`
  * })
  *
- * assert.deepStrictEqual(onLeft(These.LeftOnly({ left: 1 })), "left 1")
  * assert.deepStrictEqual(
- *   onLeft(These.LeftAndRight({ left: 1, right: "a" })),
- *   "left 1"
+ *   onWarnings(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   "warnings w"
+ * )
+ * assert.deepStrictEqual(
+ *   onWarnings(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   "warnings w"
+ * )
+ * assert.deepStrictEqual(
+ *   onWarnings(WarnResult.SuccessOnly({ success: 1 })),
+ *   "success 1"
  * )
- * assert.deepStrictEqual(onLeft(These.RightOnly({ right: "a" })), "right a")
  * ```
  *
  * @category pattern matching
  * @since 0.0.0
  */
-declare const matchLeft: <L, R, A>({ Left, RightOnly, }: {
-    Left: (left: L) => A;
-    RightOnly: (right: R) => A;
-}) => (these: These<L, R>) => A;
+declare const matchWarnings: <W, A, Z>({ Warnings, SuccessOnly, }: {
+    Warnings: (warnings: W) => Z;
+    SuccessOnly: (success: A) => Z;
+}) => (warnResult: WarnResult<W, A>) => Z;
 /**
- * Folds a `These` from the right's perspective, collapsing the three tags into two
- * handlers.
+ * Folds a `WarnResult` from the success value's perspective, collapsing the three
+ * tags into two handlers.
  *
- * The mirror of `matchLeft`: both `RightOnly` and `LeftAndRight` carry a `right`,
- * so they route to the `Right` handler; only `LeftOnly` lacks a `right` and routes
- * to `LeftOnly`. Use it when you care about the `right` value and treat the
- * left-only case as the exception.
+ * The mirror of `matchWarnings`: both `SuccessOnly` and `SuccessWithWarnings`
+ * carry a `success` value, so they route to the `Success` handler; only
+ * `WarningsOnly` lacks a `success` value and routes to `WarningsOnly`. Use it when
+ * you care about the `success` value and treat the warnings-only case as the
+ * exception.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const onRight = These.matchRight({
- *   LeftOnly: (left: number) => `left ${left}`,
- *   Right: (right: string) => `right ${right}`
+ * const onSuccess = WarnResult.matchSuccess({
+ *   WarningsOnly: (warnings: string) => `warnings ${warnings}`,
+ *   Success: (success: number) => `success ${success}`
  * })
  *
- * assert.deepStrictEqual(onRight(These.RightOnly({ right: "a" })), "right a")
  * assert.deepStrictEqual(
- *   onRight(These.LeftAndRight({ left: 1, right: "a" })),
- *   "right a"
+ *   onSuccess(WarnResult.SuccessOnly({ success: 1 })),
+ *   "success 1"
+ * )
+ * assert.deepStrictEqual(
+ *   onSuccess(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   "success 1"
+ * )
+ * assert.deepStrictEqual(
+ *   onSuccess(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   "warnings w"
  * )
- * assert.deepStrictEqual(onRight(These.LeftOnly({ left: 1 })), "left 1")
  * ```
  *
  * @category pattern matching
  * @since 0.0.0
  */
-declare const matchRight: <L, R, A>({ LeftOnly, Right, }: {
-    LeftOnly: (left: L) => A;
-    Right: (right: R) => A;
-}) => (these: These<L, R>) => A;
+declare const matchSuccess: <W, A, Z>({ WarningsOnly, Success, }: {
+    WarningsOnly: (warnings: W) => Z;
+    Success: (success: A) => Z;
+}) => (warnResult: WarnResult<W, A>) => Z;
 /**
- * Completes a `These` into a guaranteed `LeftAndRight` by filling whichever side
- * is missing from the matching `orElse` thunk.
+ * Completes a `WarnResult` into a guaranteed `SuccessWithWarnings` by filling
+ * whichever side is missing from the matching `orElse` thunk.
  *
- * A `LeftAndRight` passes through unchanged; a `LeftOnly` gains a `right` from
- * `orElseRight`; a `RightOnly` gains a `left` from `orElseLeft`. Use it to
- * normalise a partial `These` into the both-present shape before reading both
- * sides.
+ * A `SuccessWithWarnings` passes through unchanged; a `WarningsOnly` gains a
+ * `success` value from `orElseSuccess`; a `SuccessOnly` gains `warnings` from
+ * `orElseWarnings`. Use it to normalise a partial `WarnResult` into the
+ * both-present shape before reading both sides.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const fill = These.orElse({
- *   orElseLeft: () => 0,
- *   orElseRight: () => "default"
+ * const fill = WarnResult.orElse({
+ *   orElseWarnings: () => "no warnings",
+ *   orElseSuccess: () => 0
  * })
  *
  * assert.deepStrictEqual(
- *   fill(These.LeftOnly({ left: 1 })),
- *   These.LeftAndRight({ left: 1, right: "default" })
+ *   fill(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 0 })
  * )
  * assert.deepStrictEqual(
- *   fill(These.RightOnly({ right: "a" })),
- *   These.LeftAndRight({ left: 0, right: "a" })
+ *   fill(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "no warnings", success: 1 })
  * )
  * ```
  *
  * @category getters
  * @since 0.0.0
  */
-declare const orElse: <L2, R2>({ orElseLeft, orElseRight, }: {
-    orElseLeft: () => L2;
-    orElseRight: () => R2;
-}) => (<L, R>(these: These<L, R>) => LeftAndRight<L | L2, R | R2>);
+declare const orElse: <W2, A2>({ orElseWarnings, orElseSuccess, }: {
+    orElseWarnings: () => W2;
+    orElseSuccess: () => A2;
+}) => (<W, A>(warnResult: WarnResult<W, A>) => SuccessWithWarnings<W | W2, A | A2>);
 /**
- * Completes a `These` into a `LeftAndRight` whose missing side is filled with
- * `undefined`.
+ * Completes a `WarnResult` into a `SuccessWithWarnings` whose missing side is
+ * filled with `undefined`.
  *
  * A specialisation of `orElse` that supplies `undefined` for whichever side is
- * absent, so the result always exposes both `left` and `right` keys (each
+ * absent, so the result always exposes both `warnings` and `success` keys (each
  * possibly `undefined`). Use it when you want to destructure both sides without
  * branching on the tag.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
  * assert.deepStrictEqual(
- *   These.orUndefined(These.LeftOnly({ left: 1 })),
- *   These.LeftAndRight({ left: 1, right: undefined })
+ *   WarnResult.orUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: undefined })
  * )
  * assert.deepStrictEqual(
- *   These.orUndefined(These.RightOnly({ right: "a" })),
- *   These.LeftAndRight({ left: undefined, right: "a" })
+ *   WarnResult.orUndefined(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: undefined, success: 1 })
  * )
  * ```
  *
  * @category getters
  * @since 0.0.0
  */
-declare const orUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
+declare const orUndefined: <W, A>(warnResult: {
+    readonly _tag: "WarningsOnly";
+    readonly warnings: W;
 } | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
+    readonly _tag: "SuccessOnly";
+    readonly success: A;
 } | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
+    readonly _tag: "SuccessWithWarnings";
+    readonly warnings: W;
+    readonly success: A;
 }) => {
-    readonly _tag: "LeftAndRight";
-    readonly left: L | undefined;
-    readonly right: R | undefined;
+    readonly _tag: "SuccessWithWarnings";
+    readonly warnings: W | undefined;
+    readonly success: A | undefined;
 } & {
-    _tag: "LeftAndRight";
+    _tag: "SuccessWithWarnings";
 };
 /**
- * Extracts the `left` of a `These`, falling back to `orElseReturn` when no `left`
- * is present.
+ * Extracts the `warnings` of a `WarnResult`, falling back to `orElseReturn` when
+ * no `warnings` are present.
  *
- * `LeftOnly` and `LeftAndRight` return their `left`; `RightOnly` returns the
- * result of `orElseReturn`. Use it to read the left side with a default in one
- * step.
+ * `WarningsOnly` and `SuccessWithWarnings` return their `warnings`; `SuccessOnly`
+ * returns the result of `orElseReturn`. Use it to read the warnings with a default
+ * in one step.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const leftOrZero = These.leftOrElse(() => 0)
+ * const warningsOrNone = WarnResult.warningsOrElse(() => "no warnings")
  *
- * assert.deepStrictEqual(leftOrZero(These.LeftOnly({ left: 1 })), 1)
  * assert.deepStrictEqual(
- *   leftOrZero(These.LeftAndRight({ left: 1, right: "a" })),
- *   1
+ *   warningsOrNone(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   "w"
+ * )
+ * assert.deepStrictEqual(
+ *   warningsOrNone(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   "w"
+ * )
+ * assert.deepStrictEqual(
+ *   warningsOrNone(WarnResult.SuccessOnly({ success: 1 })),
+ *   "no warnings"
  * )
- * assert.deepStrictEqual(leftOrZero(These.RightOnly({ right: "a" })), 0)
  * ```
  *
  * @category getters
  * @since 0.0.0
  */
-declare const leftOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L, R>) => L | A;
+declare const warningsOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnResult: WarnResult<W, A>) => W | Z;
 /**
- * Extracts the `left` of a `These`, returning `undefined` when no `left` is
- * present.
+ * Extracts the `warnings` of a `WarnResult`, returning `undefined` when no
+ * `warnings` are present.
  *
- * A specialisation of `leftOrElse` whose fallback is `undefined`: `LeftOnly` and
- * `LeftAndRight` yield their `left`, while `RightOnly` yields `undefined`.
+ * A specialisation of `warningsOrElse` whose fallback is `undefined`:
+ * `WarningsOnly` and `SuccessWithWarnings` yield their `warnings`, while
+ * `SuccessOnly` yields `undefined`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * assert.deepStrictEqual(These.leftOrUndefined(These.LeftOnly({ left: 1 })), 1)
  * assert.deepStrictEqual(
- *   These.leftOrUndefined(These.RightOnly({ right: "a" })),
+ *   WarnResult.warningsOrUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   "w"
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.warningsOrUndefined(WarnResult.SuccessOnly({ success: 1 })),
  *   undefined
  * )
  * ```
@@ -655,61 +703,62 @@ declare const leftOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L, R
  * @category getters
  * @since 0.0.0
  */
-declare const leftOrUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
+declare const warningsOrUndefined: <W, A>(warnResult: {
+    readonly _tag: "WarningsOnly";
+    readonly warnings: W;
 } | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
+    readonly _tag: "SuccessOnly";
+    readonly success: A;
 } | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
-}) => L | undefined;
+    readonly _tag: "SuccessWithWarnings";
+    readonly warnings: W;
+    readonly success: A;
+}) => W | undefined;
 /**
- * Extracts the `right` of a `These`, falling back to `orElseReturn` when no
- * `right` is present.
+ * Extracts the `success` value of a `WarnResult`, falling back to `orElseReturn`
+ * when no `success` value is present.
  *
- * The mirror of `leftOrElse`: `RightOnly` and `LeftAndRight` return their
- * `right`; `LeftOnly` returns the result of `orElseReturn`.
+ * The mirror of `warningsOrElse`: `SuccessOnly` and `SuccessWithWarnings` return
+ * their `success` value; `WarningsOnly` returns the result of `orElseReturn`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const rightOrDefault = These.rightOrElse(() => "default")
+ * const successOrZero = WarnResult.successOrElse(() => 0)
  *
  * assert.deepStrictEqual(
- *   rightOrDefault(These.RightOnly({ right: "a" })),
- *   "a"
+ *   successOrZero(WarnResult.SuccessOnly({ success: 1 })),
+ *   1
  * )
  * assert.deepStrictEqual(
- *   rightOrDefault(These.LeftOnly({ left: 1 })),
- *   "default"
+ *   successOrZero(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   0
  * )
  * ```
  *
  * @category getters
  * @since 0.0.0
  */
-declare const rightOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L, R>) => R | A;
+declare const successOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnResult: WarnResult<W, A>) => A | Z;
 /**
- * Extracts the `right` of a `These`, returning `undefined` when no `right` is
- * present.
+ * Extracts the `success` value of a `WarnResult`, returning `undefined` when no
+ * `success` value is present.
  *
- * A specialisation of `rightOrElse` whose fallback is `undefined`: `RightOnly` and
- * `LeftAndRight` yield their `right`, while `LeftOnly` yields `undefined`.
+ * A specialisation of `successOrElse` whose fallback is `undefined`: `SuccessOnly`
+ * and `SuccessWithWarnings` yield their `success` value, while `WarningsOnly`
+ * yields `undefined`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
  * assert.deepStrictEqual(
- *   These.rightOrUndefined(These.RightOnly({ right: "a" })),
- *   "a"
+ *   WarnResult.successOrUndefined(WarnResult.SuccessOnly({ success: 1 })),
+ *   1
  * )
  * assert.deepStrictEqual(
- *   These.rightOrUndefined(These.LeftOnly({ left: 1 })),
+ *   WarnResult.successOrUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
  *   undefined
  * )
  * ```
@@ -717,35 +766,35 @@ declare const rightOrElse: <A>(orElseReturn: () => A) => <L, R>(these: These<L,
  * @category getters
  * @since 0.0.0
  */
-declare const rightOrUndefined: <L, R>(these: {
-    readonly _tag: "LeftOnly";
-    readonly left: L;
+declare const successOrUndefined: <W, A>(warnResult: {
+    readonly _tag: "WarningsOnly";
+    readonly warnings: W;
 } | {
-    readonly _tag: "RightOnly";
-    readonly right: R;
+    readonly _tag: "SuccessOnly";
+    readonly success: A;
 } | {
-    readonly _tag: "LeftAndRight";
-    readonly left: L;
-    readonly right: R;
-}) => R | undefined;
+    readonly _tag: "SuccessWithWarnings";
+    readonly warnings: W;
+    readonly success: A;
+}) => A | undefined;
 /**
- * Extracts the `right` of a `These` as an `Option`.
+ * Extracts the `success` value of a `WarnResult` as an `Option`.
  *
- * `RightOnly` and `LeftAndRight` yield `Option.some(right)`; `LeftOnly` yields
- * `Option.none()`. Use it when you want to chain the right side through `Option`
- * combinators rather than fall back to a default eagerly.
+ * `SuccessOnly` and `SuccessWithWarnings` yield `Option.some(success)`;
+ * `WarningsOnly` yields `Option.none()`. Use it when you want to chain the success
+ * value through `Option` combinators rather than fall back to a default eagerly.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   These.rightOption(These.RightOnly({ right: "a" })),
- *   Option.some("a")
+ *   WarnResult.successOption(WarnResult.SuccessOnly({ success: 1 })),
+ *   Option.some(1)
  * )
  * assert.deepStrictEqual(
- *   These.rightOption(These.LeftOnly({ left: 1 })),
+ *   WarnResult.successOption(WarnResult.WarningsOnly({ warnings: "w" })),
  *   Option.none()
  * )
  * ```
@@ -753,24 +802,24 @@ declare const rightOrUndefined: <L, R>(these: {
  * @category getters
  * @since 0.0.0
  */
-declare const rightOption: <L, R>(these: These<L, R>) => Option.Option<R>;
+declare const successOption: <W, A>(warnResult: WarnResult<W, A>) => Option.Option<A>;
 /**
- * Extracts the `left` of a `These` as an `Option`.
+ * Extracts the `warnings` of a `WarnResult` as an `Option`.
  *
- * The mirror of `rightOption`: `LeftOnly` and `LeftAndRight` yield
- * `Option.some(left)`, while `RightOnly` yields `Option.none()`.
+ * The mirror of `successOption`: `WarningsOnly` and `SuccessWithWarnings` yield
+ * `Option.some(warnings)`, while `SuccessOnly` yields `Option.none()`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Option } from "effect"
  *
  * assert.deepStrictEqual(
- *   These.leftOption(These.LeftOnly({ left: 1 })),
- *   Option.some(1)
+ *   WarnResult.warningsOption(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   Option.some("w")
  * )
  * assert.deepStrictEqual(
- *   These.leftOption(These.RightOnly({ right: "a" })),
+ *   WarnResult.warningsOption(WarnResult.SuccessOnly({ success: 1 })),
  *   Option.none()
  * )
  * ```
@@ -778,332 +827,350 @@ declare const rightOption: <L, R>(these: These<L, R>) => Option.Option<R>;
  * @category getters
  * @since 0.0.0
  */
-declare const leftOption: <L, R>(these: These<L, R>) => Option.Option<L>;
+declare const warningsOption: <W, A>(warnResult: WarnResult<W, A>) => Option.Option<W>;
 /**
- * Transforms both sides of a `These`, applying `mapLeft` to any `left` and
- * `mapRight` to any `right`.
+ * Transforms both sides of a `WarnResult`, applying `mapWarnings` to any
+ * `warnings` and `mapSuccess` to any `success` value.
  *
- * Each constructor is rebuilt with its mapped contents, so `LeftOnly` maps only
- * the left, `RightOnly` only the right, and `LeftAndRight` both. The tag is
- * preserved. Use it as the bifunctor map over `These`.
+ * Each constructor is rebuilt with its mapped contents, so `WarningsOnly` maps
+ * only the warnings, `SuccessOnly` only the success value, and
+ * `SuccessWithWarnings` both. The tag is preserved. Use it as the bifunctor map
+ * over `WarnResult`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const both = These.mapBoth({
- *   mapLeft: (left: number) => left + 1,
- *   mapRight: (right: string) => right.toUpperCase()
+ * const both = WarnResult.mapBoth({
+ *   mapWarnings: (warnings: string) => warnings.toUpperCase(),
+ *   mapSuccess: (success: number) => success + 1
  * })
  *
  * assert.deepStrictEqual(
- *   both(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 2, right: "A" })
+ *   both(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 2 })
  * )
  * assert.deepStrictEqual(
- *   both(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 2 })
+ *   both(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
  * )
  * ```
  *
  * @category mapping
  * @since 0.0.0
  */
-declare const mapBoth: <L1, R1, L2, R2>({ mapLeft, mapRight, }: {
-    mapLeft: (left: L1) => L2;
-    mapRight: (right: R1) => R2;
-}) => ((these: These<L1, R1>) => These<L2, R2>);
+declare const mapBoth: <W1, A1, W2, A2>({ mapWarnings, mapSuccess, }: {
+    mapWarnings: (warnings: W1) => W2;
+    mapSuccess: (success: A1) => A2;
+}) => ((warnResult: WarnResult<W1, A1>) => WarnResult<W2, A2>);
 /**
  * Effectful `mapBoth`: transforms each present side through an `Effect`,
- * reassembling the results into a `These` inside an `Effect`.
+ * reassembling the results into a `WarnResult` inside an `Effect`.
  *
- * For `LeftAndRight` both effects run via `Effect.all` and their results are
- * combined; `LeftOnly`/`RightOnly` run only the relevant effect. Errors and
- * requirements from both mappers are unioned into the result type. Use it when
- * mapping a `These`'s sides requires effects (validation, IO).
+ * For `SuccessWithWarnings` both effects run via `Effect.all` and their results
+ * are combined; `WarningsOnly`/`SuccessOnly` run only the relevant effect. Errors
+ * and requirements from both mappers are unioned into the result type. Use it when
+ * mapping a `WarnResult`'s sides requires effects (validation, IO).
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Effect } from "effect"
  *
- * const both = These.mapBothEffect({
- *   mapLeft: (left: number) => Effect.succeed(left + 1),
- *   mapRight: (right: string) => Effect.succeed(right.toUpperCase())
+ * const both = WarnResult.mapBothEffect({
+ *   mapWarnings: (warnings: string) => Effect.succeed(warnings.toUpperCase()),
+ *   mapSuccess: (success: number) => Effect.succeed(success + 1)
  * })
  *
  * assert.deepStrictEqual(
- *   Effect.runSync(both(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 2, right: "A" })
+ *   Effect.runSync(
+ *     both(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 2 })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const mapBothEffect: <L1, R1, L2, R2, EL, ER, RL, RR>({ mapLeft, mapRight, }: {
-    mapLeft: (left: L1) => Effect.Effect<L2, EL, RL>;
-    mapRight: (right: R1) => Effect.Effect<R2, ER, RR>;
-}) => ((these: These<L1, R1>) => Effect.Effect<These<L2, R2>, EL | ER, RL | RR>);
+declare 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>);
 /**
- * Transforms the `left` of a `These`, leaving any `right` untouched.
+ * Transforms the `warnings` of a `WarnResult`, leaving any `success` value
+ * untouched.
  *
- * A specialisation of `mapBoth` with the right mapper set to `identity`:
- * `LeftOnly` and `LeftAndRight` have their `left` mapped, while `RightOnly` passes
- * through unchanged.
+ * A specialisation of `mapBoth` with the success mapper set to `identity`:
+ * `WarningsOnly` and `SuccessWithWarnings` have their `warnings` mapped, while
+ * `SuccessOnly` passes through unchanged.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const inc = These.mapLeft((left: number) => left + 1)
+ * const shout = WarnResult.mapWarnings((warnings: string) =>
+ *   warnings.toUpperCase()
+ * )
  *
  * assert.deepStrictEqual(
- *   inc(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 2, right: "a" })
+ *   shout(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 1 })
  * )
  * assert.deepStrictEqual(
- *   inc(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "a" })
+ *   shout(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 1 })
  * )
  * ```
  *
  * @category mapping
  * @since 0.0.0
  */
-declare const mapLeft: <L1, L2>(mapLeft: (left: L1) => L2) => (<R>(these: These<L1, R>) => These<L2, R>);
+declare const mapWarnings: <W1, W2>(mapWarnings: (warnings: W1) => W2) => (<A>(warnResult: WarnResult<W1, A>) => WarnResult<W2, A>);
 /**
- * Chains the `left` of a `These` into a new `These`, flattening the result.
+ * Chains the `warnings` of a `WarnResult` into a new `WarnResult`, flattening the
+ * result.
  *
- * Whenever a `left` is present (`LeftOnly` or `LeftAndRight`) it is passed to
- * `mapLeft`, whose returned `These` replaces the original; `RightOnly` passes
- * through unchanged. Use it to sequence left-driven computations that themselves
- * produce a `These`.
+ * Whenever `warnings` are present (`WarningsOnly` or `SuccessWithWarnings`) they
+ * are passed to `mapWarnings`, whose returned `WarnResult` replaces the original;
+ * `SuccessOnly` passes through unchanged. Use it to sequence warnings-driven
+ * computations that themselves produce a `WarnResult`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const chain = These.flatMapLeft((left: number) =>
- *   left > 0
- *     ? These.LeftOnly({ left: left * 10 })
- *     : These.RightOnly({ right: "non-positive" })
+ * const chain = WarnResult.flatMapWarnings((warnings: string) =>
+ *   warnings.length > 0
+ *     ? WarnResult.WarningsOnly({ warnings: warnings.toUpperCase() })
+ *     : WarnResult.SuccessOnly({ success: 0 })
  * )
  *
  * assert.deepStrictEqual(
- *   chain(These.LeftOnly({ left: 2 })),
- *   These.LeftOnly({ left: 20 })
+ *   chain(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
  * )
  * assert.deepStrictEqual(
- *   chain(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "a" })
+ *   chain(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 1 })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const flatMapLeft: <L1, L2, R2>(mapLeft: (left: L1) => These<L2, R2>) => (<R1>(these: These<L1, R1>) => These<L2, R1 | R2>);
+declare const flatMapWarnings: <W1, W2, A2>(mapWarnings: (warnings: W1) => WarnResult<W2, A2>) => (<A1>(warnResult: WarnResult<W1, A1>) => WarnResult<W2, A1 | A2>);
 /**
- * Effectful `mapLeft`: transforms the `left` of a `These` through an `Effect`,
- * leaving any `right` untouched.
+ * Effectful `mapWarnings`: transforms the `warnings` of a `WarnResult` through an
+ * `Effect`, leaving any `success` value untouched.
  *
- * A specialisation of `mapBothEffect` with the right mapper set to
- * `Effect.succeed`: the `left` (when present) is mapped effectfully and the
- * `right` is carried through unchanged.
+ * A specialisation of `mapBothEffect` with the success mapper set to
+ * `Effect.succeed`: the `warnings` (when present) are mapped effectfully and the
+ * `success` value is carried through unchanged.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Effect } from "effect"
  *
- * const inc = These.mapLeftEffect((left: number) => Effect.succeed(left + 1))
+ * const shout = WarnResult.mapWarningsEffect((warnings: string) =>
+ *   Effect.succeed(warnings.toUpperCase())
+ * )
  *
  * assert.deepStrictEqual(
- *   Effect.runSync(inc(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 2, right: "a" })
+ *   Effect.runSync(
+ *     shout(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 1 })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const mapLeftEffect: <L1, L2, EL, RL>(mapLeft: (left: L1) => Effect.Effect<L2, EL, RL>) => (<R>(these: These<L1, R>) => Effect.Effect<These<L2, R>, EL, RL>);
+declare 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>);
 /**
- * Effectful `flatMapLeft`: chains the `left` of a `These` into an `Effect` that
- * yields a new `These`, flattening the result.
+ * Effectful `flatMapWarnings`: chains the `warnings` of a `WarnResult` into an
+ * `Effect` that yields a new `WarnResult`, flattening the result.
  *
- * When a `left` is present it is passed to `mapLeft`, whose effectful `These`
- * replaces the original; `RightOnly` is lifted unchanged via `Effect.succeed`. Use
- * it to sequence left-driven effectful computations that produce a `These`.
+ * When `warnings` are present they are passed to `mapWarnings`, whose effectful
+ * `WarnResult` replaces the original; `SuccessOnly` is lifted unchanged via
+ * `Effect.succeed`. Use it to sequence warnings-driven effectful computations that
+ * produce a `WarnResult`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Effect } from "effect"
  *
- * const chain = These.flatMapLeftEffect((left: number) =>
- *   Effect.succeed(These.LeftOnly({ left: left * 10 }))
+ * const chain = WarnResult.flatMapWarningsEffect((warnings: string) =>
+ *   Effect.succeed(WarnResult.WarningsOnly({ warnings: warnings.toUpperCase() }))
  * )
  *
  * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.LeftOnly({ left: 2 }))),
- *   These.LeftOnly({ left: 20 })
+ *   Effect.runSync(chain(WarnResult.WarningsOnly({ warnings: "w" }))),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
  * )
  * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.RightOnly({ right: "a" }))),
- *   These.RightOnly({ right: "a" })
+ *   Effect.runSync(chain(WarnResult.SuccessOnly({ success: 1 }))),
+ *   WarnResult.SuccessOnly({ success: 1 })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const flatMapLeftEffect: <L1, L2, R2, EL, RL>(mapLeft: (left: L1) => Effect.Effect<These<L2, R2>, EL, RL>) => (<R1>(these: These<L1, R1>) => Effect.Effect<These<L2, R1 | R2>, EL, RL>);
+declare 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>);
 /**
- * Transforms the `right` of a `These`, leaving any `left` untouched.
+ * Transforms the `success` value of a `WarnResult`, leaving any `warnings`
+ * untouched.
  *
- * The mirror of `mapLeft`: `RightOnly` and `LeftAndRight` have their `right`
- * mapped, while `LeftOnly` passes through unchanged.
+ * The mirror of `mapWarnings`: `SuccessOnly` and `SuccessWithWarnings` have their
+ * `success` value mapped, while `WarningsOnly` passes through unchanged.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const upper = These.mapRight((right: string) => right.toUpperCase())
+ * const inc = WarnResult.mapSuccess((success: number) => success + 1)
  *
  * assert.deepStrictEqual(
- *   upper(These.LeftAndRight({ left: 1, right: "a" })),
- *   These.LeftAndRight({ left: 1, right: "A" })
+ *   inc(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 2 })
  * )
  * assert.deepStrictEqual(
- *   upper(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 1 })
+ *   inc(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
  * )
  * ```
  *
  * @category mapping
  * @since 0.0.0
  */
-declare const mapRight: <R1, R2>(mapRight: (right: R1) => R2) => (<L>(these: These<L, R1>) => These<L, R2>);
+declare const mapSuccess: <A1, A2>(mapSuccess: (success: A1) => A2) => (<W>(warnResult: WarnResult<W, A1>) => WarnResult<W, A2>);
 /**
- * Chains the `right` of a `These` into a new `These`, flattening the result.
+ * Chains the `success` value of a `WarnResult` into a new `WarnResult`, flattening
+ * the result.
  *
- * The mirror of `flatMapLeft`: whenever a `right` is present (`RightOnly` or
- * `LeftAndRight`) it is passed to `mapRight`, whose returned `These` replaces the
- * original; `LeftOnly` passes through unchanged.
+ * The mirror of `flatMapWarnings`: whenever a `success` value is present
+ * (`SuccessOnly` or `SuccessWithWarnings`) it is passed to `mapSuccess`, whose
+ * returned `WarnResult` replaces the original; `WarningsOnly` passes through
+ * unchanged.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const chain = These.flatMapRight((right: string) =>
- *   These.RightOnly({ right: right.toUpperCase() })
+ * const chain = WarnResult.flatMapSuccess((success: number) =>
+ *   WarnResult.SuccessOnly({ success: success + 1 })
  * )
  *
  * assert.deepStrictEqual(
- *   chain(These.RightOnly({ right: "a" })),
- *   These.RightOnly({ right: "A" })
+ *   chain(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 2 })
  * )
  * assert.deepStrictEqual(
- *   chain(These.LeftOnly({ left: 1 })),
- *   These.LeftOnly({ left: 1 })
+ *   chain(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const flatMapRight: <L2, R1, R2>(mapRight: (right: R1) => These<L2, R2>) => (<L1>(these: These<L1, R1>) => These<L1 | L2, R2>);
+declare const flatMapSuccess: <W2, A1, A2>(mapSuccess: (success: A1) => WarnResult<W2, A2>) => (<W1>(warnResult: WarnResult<W1, A1>) => WarnResult<W1 | W2, A2>);
 /**
- * Effectful `mapRight`: transforms the `right` of a `These` through an `Effect`,
- * leaving any `left` untouched.
+ * Effectful `mapSuccess`: transforms the `success` value of a `WarnResult` through
+ * an `Effect`, leaving any `warnings` untouched.
  *
- * The mirror of `mapLeftEffect`: the `right` (when present) is mapped effectfully
- * and the `left` is carried through unchanged via `Effect.succeed`.
+ * The mirror of `mapWarningsEffect`: the `success` value (when present) is mapped
+ * effectfully and the `warnings` are carried through unchanged via
+ * `Effect.succeed`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Effect } from "effect"
  *
- * const upper = These.mapRightEffect((right: string) =>
- *   Effect.succeed(right.toUpperCase())
+ * const inc = WarnResult.mapSuccessEffect((success: number) =>
+ *   Effect.succeed(success + 1)
  * )
  *
  * assert.deepStrictEqual(
- *   Effect.runSync(upper(These.LeftAndRight({ left: 1, right: "a" }))),
- *   These.LeftAndRight({ left: 1, right: "A" })
+ *   Effect.runSync(
+ *     inc(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 2 })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const mapRightEffect: <R1, R2, ER, RR>(mapRight: (right: R1) => Effect.Effect<R2, ER, RR>) => (<L>(these: These<L, R1>) => Effect.Effect<These<L, R2>, ER, RR>);
+declare 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>);
 /**
- * Effectful `flatMapRight`: chains the `right` of a `These` into an `Effect` that
- * yields a new `These`, flattening the result.
+ * Effectful `flatMapSuccess`: chains the `success` value of a `WarnResult` into an
+ * `Effect` that yields a new `WarnResult`, flattening the result.
  *
- * The mirror of `flatMapLeftEffect`: when a `right` is present it is passed to
- * `mapRight`, whose effectful `These` replaces the original; `LeftOnly` is lifted
- * unchanged via `Effect.succeed`.
+ * The mirror of `flatMapWarningsEffect`: when a `success` value is present it is
+ * passed to `mapSuccess`, whose effectful `WarnResult` replaces the original;
+ * `WarningsOnly` is lifted unchanged via `Effect.succeed`.
  *
  * @example
  * ```ts
- * import { These } from "@nunofyobiz/effect-extras"
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
  * import { Effect } from "effect"
  *
- * const chain = These.flatMapRightEffect((right: string) =>
- *   Effect.succeed(These.RightOnly({ right: right.toUpperCase() }))
+ * const chain = WarnResult.flatMapSuccessEffect((success: number) =>
+ *   Effect.succeed(WarnResult.SuccessOnly({ success: success + 1 }))
  * )
  *
  * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.RightOnly({ right: "a" }))),
- *   These.RightOnly({ right: "A" })
+ *   Effect.runSync(chain(WarnResult.SuccessOnly({ success: 1 }))),
+ *   WarnResult.SuccessOnly({ success: 2 })
  * )
  * assert.deepStrictEqual(
- *   Effect.runSync(chain(These.LeftOnly({ left: 1 }))),
- *   These.LeftOnly({ left: 1 })
+ *   Effect.runSync(chain(WarnResult.WarningsOnly({ warnings: "w" }))),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
  * )
  * ```
  *
  * @category sequencing
  * @since 0.0.0
  */
-declare const flatMapRightEffect: <L2, R1, R2, ER, RR>(mapRight: (right: R1) => Effect.Effect<These<L2, R2>, ER, RR>) => (<L1>(these: These<L1, R1>) => Effect.Effect<These<L1 | L2, R2>, ER, RR>);
+declare 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>);
 
-declare const These$1_LeftAndRight: typeof LeftAndRight;
-declare const These$1_LeftOnly: typeof LeftOnly;
-declare const These$1_RightOnly: typeof RightOnly;
-type These$1_These<L, R> = These<L, R>;
-declare const These$1_WithLeft: typeof WithLeft;
-declare const These$1_WithRight: typeof WithRight;
-declare const These$1_flatMapLeft: typeof flatMapLeft;
-declare const These$1_flatMapLeftEffect: typeof flatMapLeftEffect;
-declare const These$1_flatMapRight: typeof flatMapRight;
-declare const These$1_flatMapRightEffect: typeof flatMapRightEffect;
-declare const These$1_fromNullables: typeof fromNullables;
-declare const These$1_is: typeof is;
-declare const These$1_leftOption: typeof leftOption;
-declare const These$1_leftOrElse: typeof leftOrElse;
-declare const These$1_leftOrUndefined: typeof leftOrUndefined;
-declare const These$1_mapBoth: typeof mapBoth;
-declare const These$1_mapBothEffect: typeof mapBothEffect;
-declare const These$1_mapLeft: typeof mapLeft;
-declare const These$1_mapLeftEffect: typeof mapLeftEffect;
-declare const These$1_mapRight: typeof mapRight;
-declare const These$1_mapRightEffect: typeof mapRightEffect;
-declare const These$1_matchLeft: typeof matchLeft;
-declare const These$1_matchRight: typeof matchRight;
-declare const These$1_optionFromNullables: typeof optionFromNullables;
-declare const These$1_orElse: typeof orElse;
-declare const These$1_orUndefined: typeof orUndefined;
-declare const These$1_rightOption: typeof rightOption;
-declare const These$1_rightOrElse: typeof rightOrElse;
-declare const These$1_rightOrUndefined: typeof rightOrUndefined;
-declare namespace These$1 {
-  export { These$1_LeftAndRight as LeftAndRight, These$1_LeftOnly as LeftOnly, These$1_RightOnly as RightOnly, type These$1_These as These, These$1_WithLeft as WithLeft, These$1_WithRight as WithRight, These$1_flatMapLeft as flatMapLeft, These$1_flatMapLeftEffect as flatMapLeftEffect, These$1_flatMapRight as flatMapRight, These$1_flatMapRightEffect as flatMapRightEffect, These$1_fromNullables as fromNullables, These$1_is as is, These$1_leftOption as leftOption, These$1_leftOrElse as leftOrElse, These$1_leftOrUndefined as leftOrUndefined, These$1_mapBoth as mapBoth, These$1_mapBothEffect as mapBothEffect, These$1_mapLeft as mapLeft, These$1_mapLeftEffect as mapLeftEffect, These$1_mapRight as mapRight, These$1_mapRightEffect as mapRightEffect, match$1 as match, These$1_matchLeft as matchLeft, These$1_matchRight as matchRight, These$1_optionFromNullables as optionFromNullables, These$1_orElse as orElse, These$1_orUndefined as orUndefined, These$1_rightOption as rightOption, These$1_rightOrElse as rightOrElse, These$1_rightOrUndefined as rightOrUndefined };
+declare const WarnResult$1_SuccessOnly: typeof SuccessOnly;
+declare const WarnResult$1_SuccessWithWarnings: typeof SuccessWithWarnings;
+type WarnResult$1_WarnResult<W, A> = WarnResult<W, A>;
+declare const WarnResult$1_WarningsOnly: typeof WarningsOnly;
+declare const WarnResult$1_WithSuccess: typeof WithSuccess;
+declare const WarnResult$1_WithWarnings: typeof WithWarnings;
+declare const WarnResult$1_flatMapSuccess: typeof flatMapSuccess;
+declare const WarnResult$1_flatMapSuccessEffect: typeof flatMapSuccessEffect;
+declare const WarnResult$1_flatMapWarnings: typeof flatMapWarnings;
+declare const WarnResult$1_flatMapWarningsEffect: typeof flatMapWarningsEffect;
+declare const WarnResult$1_fromNullables: typeof fromNullables;
+declare const WarnResult$1_is: typeof is;
+declare const WarnResult$1_mapBoth: typeof mapBoth;
+declare const WarnResult$1_mapBothEffect: typeof mapBothEffect;
+declare const WarnResult$1_mapSuccess: typeof mapSuccess;
+declare const WarnResult$1_mapSuccessEffect: typeof mapSuccessEffect;
+declare const WarnResult$1_mapWarnings: typeof mapWarnings;
+declare const WarnResult$1_mapWarningsEffect: typeof mapWarningsEffect;
+declare const WarnResult$1_matchSuccess: typeof matchSuccess;
+declare const WarnResult$1_matchWarnings: typeof matchWarnings;
+declare const WarnResult$1_optionFromNullables: typeof optionFromNullables;
+declare const WarnResult$1_orElse: typeof orElse;
+declare const WarnResult$1_orUndefined: typeof orUndefined;
+declare const WarnResult$1_successOption: typeof successOption;
+declare const WarnResult$1_successOrElse: typeof successOrElse;
+declare const WarnResult$1_successOrUndefined: typeof successOrUndefined;
+declare const WarnResult$1_warningsOption: typeof warningsOption;
+declare const WarnResult$1_warningsOrElse: typeof warningsOrElse;
+declare const WarnResult$1_warningsOrUndefined: typeof warningsOrUndefined;
+declare namespace WarnResult$1 {
+  export { WarnResult$1_SuccessOnly as SuccessOnly, WarnResult$1_SuccessWithWarnings as SuccessWithWarnings, type WarnResult$1_WarnResult as WarnResult, WarnResult$1_WarningsOnly as WarningsOnly, WarnResult$1_WithSuccess as WithSuccess, WarnResult$1_WithWarnings as WithWarnings, WarnResult$1_flatMapSuccess as flatMapSuccess, WarnResult$1_flatMapSuccessEffect as flatMapSuccessEffect, WarnResult$1_flatMapWarnings as flatMapWarnings, WarnResult$1_flatMapWarningsEffect as flatMapWarningsEffect, WarnResult$1_fromNullables as fromNullables, WarnResult$1_is as is, WarnResult$1_mapBoth as mapBoth, WarnResult$1_mapBothEffect as mapBothEffect, WarnResult$1_mapSuccess as mapSuccess, WarnResult$1_mapSuccessEffect as mapSuccessEffect, WarnResult$1_mapWarnings as mapWarnings, WarnResult$1_mapWarningsEffect as mapWarningsEffect, match$1 as match, WarnResult$1_matchSuccess as matchSuccess, WarnResult$1_matchWarnings as matchWarnings, WarnResult$1_optionFromNullables as optionFromNullables, WarnResult$1_orElse as orElse, WarnResult$1_orUndefined as orUndefined, WarnResult$1_successOption as successOption, WarnResult$1_successOrElse as successOrElse, WarnResult$1_successOrUndefined as successOrUndefined, WarnResult$1_warningsOption as warningsOption, WarnResult$1_warningsOrElse as warningsOrElse, WarnResult$1_warningsOrUndefined as warningsOrUndefined };
 }
 
 /**
@@ -1137,36 +1204,38 @@ declare namespace These$1 {
  */
 declare const slice: (<A>(start: number, end: number) => (array: readonly A[]) => A[]) & (<A>(array: readonly A[], start: number, end: number) => A[]);
 /**
- * Zips two arrays into one, calling `f` with a `These` for each index so that
- * length mismatches are handled explicitly rather than truncated.
+ * 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. At each index `f` receives a `These.These<A, B>`:
- * `LeftAndRight` when both arrays have an element, `LeftOnly` when only the
- * first does, and `RightOnly` when only the second does. Use it when the
- * "extra" tail of either array still carries meaning.
+ * 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<A, B>`: `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 { ArrayX, These } from "@nunofyobiz/effect-extras"
+ * import { ArrayX, WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const describe = These.match({
- *   LeftOnly: ({ left }) => `left ${left}`,
- *   RightOnly: ({ right }) => `right ${right}`,
- *   LeftAndRight: ({ left, right }) => `both ${left}/${right}`,
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`,
  * })
  *
- * assert.deepStrictEqual(ArrayX.zipWithThese([1, 2, 3], [10, 20], describe), [
+ * assert.deepStrictEqual(ArrayX.zipWithWarnings([1, 2, 3], [10, 20], describe), [
  *   "both 1/10",
  *   "both 2/20",
- *   "left 3",
+ *   "warnings 3",
  * ])
  * ```
  *
  * @category combinators
  * @since 0.0.0
  */
-declare const zipWithThese: (<A, B, C>(f: (ab: These<A, B>) => C) => (array1: readonly A[], array2: readonly B[]) => C[]) & (<A, B, C>(array1: readonly A[], array2: readonly B[], f: (ab: These<A, B>) => C) => C[]);
+declare const zipWithWarnings: (<A, B, C>(f: (ab: WarnResult<A, B>) => C) => (array1: readonly A[], array2: readonly B[]) => C[]) & (<A, B, C>(array1: readonly A[], array2: readonly B[], f: (ab: WarnResult<A, B>) => C) => C[]);
 /**
  * Inserts or moves a unique item in an array at a specified position.
  *
@@ -1529,9 +1598,9 @@ declare const ArrayX_insertUniq: typeof insertUniq;
 declare const ArrayX_mapRightAccum: typeof mapRightAccum;
 declare const ArrayX_maxOption: typeof maxOption;
 declare const ArrayX_slice: typeof slice;
-declare const ArrayX_zipWithThese: typeof zipWithThese;
+declare const ArrayX_zipWithWarnings: typeof zipWithWarnings;
 declare namespace ArrayX {
-  export { ArrayX_categorize as categorize, ArrayX_chunkBy as chunkBy, ArrayX_compactNullable as compactNullable, ArrayX_filterHead as filterHead, ArrayX_filterMapNullable as filterMapNullable, ArrayX_filterTail as filterTail, ArrayX_findFirstWithIndex2d as findFirstWithIndex2d, ArrayX_insertUniq as insertUniq, ArrayX_mapRightAccum as mapRightAccum, ArrayX_maxOption as maxOption, ArrayX_slice as slice, takeFirstWhere$1 as takeFirstWhere, takeLastWhere$1 as takeLastWhere, ArrayX_zipWithThese as zipWithThese };
+  export { ArrayX_categorize as categorize, ArrayX_chunkBy as chunkBy, ArrayX_compactNullable as compactNullable, ArrayX_filterHead as filterHead, ArrayX_filterMapNullable as filterMapNullable, ArrayX_filterTail as filterTail, ArrayX_findFirstWithIndex2d as findFirstWithIndex2d, ArrayX_insertUniq as insertUniq, ArrayX_mapRightAccum as mapRightAccum, ArrayX_maxOption as maxOption, ArrayX_slice as slice, takeFirstWhere$1 as takeFirstWhere, takeLastWhere$1 as takeLastWhere, ArrayX_zipWithWarnings as zipWithWarnings };
 }
 
 /**
@@ -3700,4 +3769,4 @@ declare namespace StructX {
   export { type StructX_PartialTransform as PartialTransform, StructX_defined as defined, StructX_filterDefined as filterDefined, StructX_hasNotNullableProperty as hasNotNullableProperty, StructX_pickSome as pickSome, StructX_some as some, StructX_truthy as truthy };
 }
 
-export { ArrayX, BigIntX, BooleanX, DurationX, EffectX, FormDataX, MapX, NonNullableX, NumberX, OptionX, OrderX, PredicateX, PromiseX, RecordX, ResultX, SchemaX, SetX, StringX, StructX, These$1 as These, fromNullableOrThrow as nn };
+export { ArrayX, BigIntX, BooleanX, DurationX, EffectX, FormDataX, MapX, NonNullableX, NumberX, OptionX, OrderX, PredicateX, PromiseX, RecordX, ResultX, SchemaX, SetX, StringX, StructX, WarnResult$1 as WarnResult, fromNullableOrThrow as nn };