@nunofyobiz/effect-extras 2.0.0 → 2.1.0

package/dist/WarnResult.js

@@ -0,0 +1,1060 @@
+/**
+ * The `WarnResult` data type — a result that may carry a success value and/or
+ * warnings, where both sides are optional but never both absent.
+ *
+ * @since 0.0.0
+ */
+import { Data, Effect, Option, Predicate, Struct, pipe } from "effect";
+import { constUndefined, identity } from "effect/Function";
+const taggedEnum = /*#__PURE__*/Data.taggedEnum();
+/**
+ * Constructs a `WarningsOnly` — a `WarnResult` that carries only `warnings`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const value = WarnResult.WarningsOnly({ warnings: "skipped 2 rows" })
+ *
+ * assert.deepStrictEqual(value._tag, "WarningsOnly")
+ * assert.deepStrictEqual(value.warnings, "skipped 2 rows")
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const WarningsOnly = taggedEnum.WarningsOnly;
+/**
+ * Constructs a `SuccessOnly` — a `WarnResult` that carries only a `success` value.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const value = WarnResult.SuccessOnly({ success: 1 })
+ *
+ * assert.deepStrictEqual(value._tag, "SuccessOnly")
+ * assert.deepStrictEqual(value.success, 1)
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const SuccessOnly = taggedEnum.SuccessOnly;
+/**
+ * Constructs a `SuccessWithWarnings` — a `WarnResult` that carries both a
+ * `success` value and `warnings`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const value = WarnResult.SuccessWithWarnings({
+ *   warnings: "rounded down",
+ *   success: 1
+ * })
+ *
+ * assert.deepStrictEqual(value._tag, "SuccessWithWarnings")
+ * assert.deepStrictEqual(value.warnings, "rounded down")
+ * assert.deepStrictEqual(value.success, 1)
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const SuccessWithWarnings = taggedEnum.SuccessWithWarnings;
+/**
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.is("WarningsOnly")(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   true
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.is("WarningsOnly")(WarnResult.SuccessOnly({ success: 1 })),
+ *   false
+ * )
+ * ```
+ *
+ * @category guards
+ * @since 0.0.0
+ */
+export const is = taggedEnum.$is;
+/**
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   describe(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   "both w/1"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export const match = taggedEnum.$match;
+/**
+ * Builds a `WarnResult` known to carry `warnings`, choosing `SuccessWithWarnings`
+ * when a `success` value is present and `WarningsOnly` otherwise.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.WithWarnings({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.WithWarnings({ warnings: "w" }),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const WithWarnings = ({
+  warnings,
+  success
+}) => Predicate.isNotNullish(success) ? SuccessWithWarnings({
+  warnings,
+  success
+}) : WarningsOnly({
+  warnings
+});
+/**
+ * Builds a `WarnResult` known to carry a `success` value, choosing
+ * `SuccessWithWarnings` when `warnings` are present and `SuccessOnly` otherwise.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.WithSuccess({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.WithSuccess({ success: 1 }),
+ *   WarnResult.SuccessOnly({ success: 1 })
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const WithSuccess = ({
+  warnings,
+  success
+}) => Predicate.isNotNullish(warnings) ? SuccessWithWarnings({
+  warnings,
+  success
+}) : SuccessOnly({
+  success
+});
+/**
+ * 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(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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.optionFromNullables({ warnings: "w", success: 1 }),
+ *   Option.some(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.optionFromNullables({ warnings: "w", success: null }),
+ *   Option.some(WarnResult.WarningsOnly({ warnings: "w" }))
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.optionFromNullables({ warnings: null, success: undefined }),
+ *   Option.none()
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const optionFromNullables = ({
+  warnings,
+  success
+}) => {
+  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();
+};
+/**
+ * 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
+ * default `orElse` throws, so omit it only when at least one side is guaranteed
+ * present.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.fromNullables({ warnings: "w", success: 1 }),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })
+ * )
+ *
+ * // Both absent — fall back via orElse instead of throwing
+ * assert.deepStrictEqual(
+ *   WarnResult.fromNullables({
+ *     warnings: null,
+ *     success: null,
+ *     orElse: () => WarnResult.WarningsOnly({ warnings: "none" })
+ *   }),
+ *   WarnResult.WarningsOnly({ warnings: "none" })
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.0.0
+ */
+export const fromNullables = ({
+  warnings,
+  success,
+  orElse = () => {
+    throw new Error("Both warnings and success are nullish");
+  }
+}) => pipe(optionFromNullables({
+  warnings,
+  success
+}), Option.getOrElse(orElse));
+/**
+ * Folds a `WarnResult` from the warnings' perspective, collapsing the three tags
+ * into two handlers.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const onWarnings = WarnResult.matchWarnings({
+ *   Warnings: (warnings: string) => `warnings ${warnings}`,
+ *   SuccessOnly: (success: number) => `success ${success}`
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   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"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export const matchWarnings = ({
+  Warnings,
+  SuccessOnly
+}) => warnResult => pipe(warnResult, match({
+  WarningsOnly: ({
+    warnings
+  }) => Warnings(warnings),
+  SuccessOnly: ({
+    success
+  }) => SuccessOnly(success),
+  SuccessWithWarnings: ({
+    warnings
+  }) => Warnings(warnings)
+}),
+// Make Typescript happy
+a => a);
+/**
+ * Folds a `WarnResult` from the success value's perspective, collapsing the three
+ * tags into two handlers.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const onSuccess = WarnResult.matchSuccess({
+ *   WarningsOnly: (warnings: string) => `warnings ${warnings}`,
+ *   Success: (success: number) => `success ${success}`
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   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"
+ * )
+ * ```
+ *
+ * @category pattern matching
+ * @since 0.0.0
+ */
+export const matchSuccess = ({
+  WarningsOnly,
+  Success
+}) => warnResult => pipe(warnResult, match({
+  WarningsOnly: ({
+    warnings
+  }) => WarningsOnly(warnings),
+  SuccessOnly: ({
+    success
+  }) => Success(success),
+  SuccessWithWarnings: ({
+    success
+  }) => Success(success)
+}),
+// Make Typescript happy
+a => a);
+/**
+ * Completes a `WarnResult` into a guaranteed `SuccessWithWarnings` by filling
+ * whichever side is missing from the matching `orElse` thunk.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const fill = WarnResult.orElse({
+ *   orElseWarnings: () => "no warnings",
+ *   orElseSuccess: () => 0
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   fill(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 0 })
+ * )
+ * assert.deepStrictEqual(
+ *   fill(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "no warnings", success: 1 })
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const orElse = ({
+  orElseWarnings,
+  orElseSuccess
+}) => match({
+  WarningsOnly: ({
+    warnings
+  }) => SuccessWithWarnings({
+    warnings,
+    success: orElseSuccess()
+  }),
+  SuccessOnly: ({
+    success
+  }) => SuccessWithWarnings({
+    warnings: orElseWarnings(),
+    success
+  }),
+  SuccessWithWarnings: ({
+    warnings,
+    success
+  }) => SuccessWithWarnings({
+    warnings,
+    success
+  })
+});
+/**
+ * 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 `warnings` and `success` keys (each
+ * possibly `undefined`). Use it when you want to destructure both sides without
+ * branching on the tag.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.orUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: undefined })
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.orUndefined(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: undefined, success: 1 })
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const orUndefined = /*#__PURE__*/orElse({
+  orElseWarnings: () => undefined,
+  orElseSuccess: () => undefined
+});
+/**
+ * Extracts the `warnings` of a `WarnResult`, falling back to `orElseReturn` when
+ * no `warnings` are present.
+ *
+ * `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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const warningsOrNone = WarnResult.warningsOrElse(() => "no warnings")
+ *
+ * assert.deepStrictEqual(
+ *   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"
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const warningsOrElse = orElseReturn => warnResult => pipe(warnResult, orElse({
+  orElseWarnings: orElseReturn,
+  orElseSuccess: constUndefined
+}), Struct.get("warnings"));
+/**
+ * Extracts the `warnings` of a `WarnResult`, returning `undefined` when no
+ * `warnings` are present.
+ *
+ * A specialisation of `warningsOrElse` whose fallback is `undefined`:
+ * `WarningsOnly` and `SuccessWithWarnings` yield their `warnings`, while
+ * `SuccessOnly` yields `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.warningsOrUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   "w"
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.warningsOrUndefined(WarnResult.SuccessOnly({ success: 1 })),
+ *   undefined
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const warningsOrUndefined = /*#__PURE__*/warningsOrElse(() => undefined);
+/**
+ * Extracts the `success` value of a `WarnResult`, falling back to `orElseReturn`
+ * when no `success` value is present.
+ *
+ * The mirror of `warningsOrElse`: `SuccessOnly` and `SuccessWithWarnings` return
+ * their `success` value; `WarningsOnly` returns the result of `orElseReturn`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const successOrZero = WarnResult.successOrElse(() => 0)
+ *
+ * assert.deepStrictEqual(
+ *   successOrZero(WarnResult.SuccessOnly({ success: 1 })),
+ *   1
+ * )
+ * assert.deepStrictEqual(
+ *   successOrZero(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   0
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const successOrElse = orElseReturn => warnResult => pipe(warnResult, orElse({
+  orElseWarnings: constUndefined,
+  orElseSuccess: orElseReturn
+}), Struct.get("success"));
+/**
+ * Extracts the `success` value of a `WarnResult`, returning `undefined` when no
+ * `success` value is present.
+ *
+ * A specialisation of `successOrElse` whose fallback is `undefined`: `SuccessOnly`
+ * and `SuccessWithWarnings` yield their `success` value, while `WarningsOnly`
+ * yields `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.successOrUndefined(WarnResult.SuccessOnly({ success: 1 })),
+ *   1
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.successOrUndefined(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   undefined
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const successOrUndefined = /*#__PURE__*/successOrElse(() => undefined);
+/**
+ * Extracts the `success` value of a `WarnResult` as an `Option`.
+ *
+ * `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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.successOption(WarnResult.SuccessOnly({ success: 1 })),
+ *   Option.some(1)
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.successOption(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   Option.none()
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const successOption = warnResult => pipe(warnResult, matchSuccess({
+  WarningsOnly: () => Option.none(),
+  Success: Option.some
+}));
+/**
+ * Extracts the `warnings` of a `WarnResult` as an `Option`.
+ *
+ * The mirror of `successOption`: `WarningsOnly` and `SuccessWithWarnings` yield
+ * `Option.some(warnings)`, while `SuccessOnly` yields `Option.none()`.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Option } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   WarnResult.warningsOption(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   Option.some("w")
+ * )
+ * assert.deepStrictEqual(
+ *   WarnResult.warningsOption(WarnResult.SuccessOnly({ success: 1 })),
+ *   Option.none()
+ * )
+ * ```
+ *
+ * @category getters
+ * @since 0.0.0
+ */
+export const warningsOption = warnResult => pipe(warnResult, matchWarnings({
+  Warnings: Option.some,
+  SuccessOnly: () => Option.none()
+}));
+/**
+ * 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 `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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const both = WarnResult.mapBoth({
+ *   mapWarnings: (warnings: string) => warnings.toUpperCase(),
+ *   mapSuccess: (success: number) => success + 1
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   both(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 2 })
+ * )
+ * assert.deepStrictEqual(
+ *   both(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const mapBoth = ({
+  mapWarnings,
+  mapSuccess
+}) => match({
+  WarningsOnly: ({
+    warnings
+  }) => WarningsOnly({
+    warnings: mapWarnings(warnings)
+  }),
+  SuccessOnly: ({
+    success
+  }) => SuccessOnly({
+    success: mapSuccess(success)
+  }),
+  SuccessWithWarnings: ({
+    warnings,
+    success
+  }) => SuccessWithWarnings({
+    warnings: mapWarnings(warnings),
+    success: mapSuccess(success)
+  })
+});
+/**
+ * Effectful `mapBoth`: transforms each present side through an `Effect`,
+ * reassembling the results into a `WarnResult` inside an `Effect`.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Effect } from "effect"
+ *
+ * const both = WarnResult.mapBothEffect({
+ *   mapWarnings: (warnings: string) => Effect.succeed(warnings.toUpperCase()),
+ *   mapSuccess: (success: number) => Effect.succeed(success + 1)
+ * })
+ *
+ * assert.deepStrictEqual(
+ *   Effect.runSync(
+ *     both(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 2 })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const mapBothEffect = ({
+  mapWarnings,
+  mapSuccess
+}) => 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
+  })))
+});
+/**
+ * Transforms the `warnings` of a `WarnResult`, leaving any `success` value
+ * untouched.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const shout = WarnResult.mapWarnings((warnings: string) =>
+ *   warnings.toUpperCase()
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   shout(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 1 })
+ * )
+ * assert.deepStrictEqual(
+ *   shout(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 1 })
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const mapWarnings = mapWarnings => mapBoth({
+  mapWarnings,
+  mapSuccess: identity
+});
+/**
+ * Chains the `warnings` of a `WarnResult` into a new `WarnResult`, flattening the
+ * result.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const chain = WarnResult.flatMapWarnings((warnings: string) =>
+ *   warnings.length > 0
+ *     ? WarnResult.WarningsOnly({ warnings: warnings.toUpperCase() })
+ *     : WarnResult.SuccessOnly({ success: 0 })
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   chain(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
+ * )
+ * assert.deepStrictEqual(
+ *   chain(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 1 })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const flatMapWarnings = mapWarnings => match({
+  WarningsOnly: ({
+    warnings
+  }) => mapWarnings(warnings),
+  SuccessOnly: ({
+    success
+  }) => SuccessOnly({
+    success
+  }),
+  SuccessWithWarnings: ({
+    warnings
+  }) => mapWarnings(warnings)
+});
+/**
+ * Effectful `mapWarnings`: transforms the `warnings` of a `WarnResult` through an
+ * `Effect`, leaving any `success` value untouched.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Effect } from "effect"
+ *
+ * const shout = WarnResult.mapWarningsEffect((warnings: string) =>
+ *   Effect.succeed(warnings.toUpperCase())
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   Effect.runSync(
+ *     shout(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "W", success: 1 })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const mapWarningsEffect = mapWarnings => mapBothEffect({
+  mapWarnings,
+  mapSuccess: Effect.succeed
+});
+/**
+ * Effectful `flatMapWarnings`: chains the `warnings` of a `WarnResult` into an
+ * `Effect` that yields a new `WarnResult`, flattening the result.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Effect } from "effect"
+ *
+ * const chain = WarnResult.flatMapWarningsEffect((warnings: string) =>
+ *   Effect.succeed(WarnResult.WarningsOnly({ warnings: warnings.toUpperCase() }))
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   Effect.runSync(chain(WarnResult.WarningsOnly({ warnings: "w" }))),
+ *   WarnResult.WarningsOnly({ warnings: "W" })
+ * )
+ * assert.deepStrictEqual(
+ *   Effect.runSync(chain(WarnResult.SuccessOnly({ success: 1 }))),
+ *   WarnResult.SuccessOnly({ success: 1 })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const flatMapWarningsEffect = mapWarnings => match({
+  WarningsOnly: ({
+    warnings
+  }) => mapWarnings(warnings),
+  SuccessOnly: ({
+    success
+  }) => Effect.succeed(SuccessOnly({
+    success
+  })),
+  SuccessWithWarnings: ({
+    warnings
+  }) => mapWarnings(warnings)
+});
+/**
+ * Transforms the `success` value of a `WarnResult`, leaving any `warnings`
+ * untouched.
+ *
+ * The mirror of `mapWarnings`: `SuccessOnly` and `SuccessWithWarnings` have their
+ * `success` value mapped, while `WarningsOnly` passes through unchanged.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const inc = WarnResult.mapSuccess((success: number) => success + 1)
+ *
+ * assert.deepStrictEqual(
+ *   inc(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 })),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 2 })
+ * )
+ * assert.deepStrictEqual(
+ *   inc(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
+ * )
+ * ```
+ *
+ * @category mapping
+ * @since 0.0.0
+ */
+export const mapSuccess = mapSuccess => mapBoth({
+  mapWarnings: identity,
+  mapSuccess
+});
+/**
+ * Chains the `success` value of a `WarnResult` into a new `WarnResult`, flattening
+ * the result.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ *
+ * const chain = WarnResult.flatMapSuccess((success: number) =>
+ *   WarnResult.SuccessOnly({ success: success + 1 })
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   chain(WarnResult.SuccessOnly({ success: 1 })),
+ *   WarnResult.SuccessOnly({ success: 2 })
+ * )
+ * assert.deepStrictEqual(
+ *   chain(WarnResult.WarningsOnly({ warnings: "w" })),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const flatMapSuccess = mapSuccess => match({
+  WarningsOnly: ({
+    warnings
+  }) => WarningsOnly({
+    warnings
+  }),
+  SuccessOnly: ({
+    success
+  }) => mapSuccess(success),
+  SuccessWithWarnings: ({
+    success
+  }) => mapSuccess(success)
+});
+/**
+ * Effectful `mapSuccess`: transforms the `success` value of a `WarnResult` through
+ * an `Effect`, leaving any `warnings` untouched.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Effect } from "effect"
+ *
+ * const inc = WarnResult.mapSuccessEffect((success: number) =>
+ *   Effect.succeed(success + 1)
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   Effect.runSync(
+ *     inc(WarnResult.SuccessWithWarnings({ warnings: "w", success: 1 }))
+ *   ),
+ *   WarnResult.SuccessWithWarnings({ warnings: "w", success: 2 })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const mapSuccessEffect = mapSuccess => mapBothEffect({
+  mapWarnings: Effect.succeed,
+  mapSuccess
+});
+/**
+ * Effectful `flatMapSuccess`: chains the `success` value of a `WarnResult` into an
+ * `Effect` that yields a new `WarnResult`, flattening the result.
+ *
+ * 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 { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { Effect } from "effect"
+ *
+ * const chain = WarnResult.flatMapSuccessEffect((success: number) =>
+ *   Effect.succeed(WarnResult.SuccessOnly({ success: success + 1 }))
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   Effect.runSync(chain(WarnResult.SuccessOnly({ success: 1 }))),
+ *   WarnResult.SuccessOnly({ success: 2 })
+ * )
+ * assert.deepStrictEqual(
+ *   Effect.runSync(chain(WarnResult.WarningsOnly({ warnings: "w" }))),
+ *   WarnResult.WarningsOnly({ warnings: "w" })
+ * )
+ * ```
+ *
+ * @category sequencing
+ * @since 0.0.0
+ */
+export const flatMapSuccessEffect = mapSuccess => match({
+  WarningsOnly: ({
+    warnings
+  }) => Effect.succeed(WarningsOnly({
+    warnings
+  })),
+  SuccessOnly: ({
+    success
+  }) => mapSuccess(success),
+  SuccessWithWarnings: ({
+    success
+  }) => mapSuccess(success)
+});
+//# sourceMappingURL=WarnResult.js.map