@nunofyobiz/effect-extras 2.1.0 → 3.1.0

package/dist/StringX.d.ts

@@ -67,4 +67,65 @@ export declare const surround: ((start: string, end: string) => (string_: string
  * @since 0.0.0
  */
 export declare const ensurePrepend: ((start: string) => (string_: string) => string) & ((string_: string, start: string) => string);
+/**
+ * Replaces the inclusive line range `[startLine, endLine]` of `content` with
+ * `replacement` lines, returning the rejoined string.
+ *
+ * `content` is split on `\n`; the zero-based lines `startLine` through `endLine`
+ * (both inclusive) are dropped and `replacement` is spliced into their place.
+ * Pass an empty `replacement` to delete the range. Indices clamp naturally via
+ * `Array.take`/`Array.drop`, so out-of-range values don't throw.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — replace lines 1..2 with a single line
+ * assert.deepStrictEqual(
+ *   StringX.replaceLineRange("a\nb\nc\nd", 1, 2, ["X"]),
+ *   "a\nX\nd",
+ * )
+ *
+ * // an empty replacement deletes the range
+ * assert.deepStrictEqual(StringX.replaceLineRange("a\nb\nc\nd", 1, 2, []), "a\nd")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(
+ *   pipe("a\nb\nc", StringX.replaceLineRange(1, 1, ["X", "Y"])),
+ *   "a\nX\nY\nc",
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const replaceLineRange: ((startLine: number, endLine: number, replacement: readonly string[]) => (content: string) => string) & ((content: string, startLine: number, endLine: number, replacement: readonly string[]) => string);
+/**
+ * Inserts `lines` immediately before the line at `anchorIndex`, preserving the
+ * anchor line and everything after it; returns the rejoined string.
+ *
+ * `content` is split on `\n` and `lines` are spliced in just before the
+ * zero-based `anchorIndex`. An `anchorIndex` of `0` prepends, and one at or past
+ * the end appends.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — insert before line 1, keeping the anchor and the rest
+ * assert.deepStrictEqual(StringX.insertBeforeLine("a\nb\nc", 1, ["X"]), "a\nX\nb\nc")
+ *
+ * // an anchor at the end appends
+ * assert.deepStrictEqual(StringX.insertBeforeLine("a\nb", 2, ["X"]), "a\nb\nX")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("a\nb", StringX.insertBeforeLine(0, ["X"])), "X\na\nb")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const insertBeforeLine: ((anchorIndex: number, lines: readonly string[]) => (content: string) => string) & ((content: string, anchorIndex: number, lines: readonly string[]) => string);
 //# sourceMappingURL=StringX.d.ts.map

package/dist/StringX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StringX.d.ts","sourceRoot":"","sources":["../src/StringX.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,WACV,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAC0B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,OAAO,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACjD,MAAM,SAAS,MAAM,OAAO,MAAM,KAAK,MAAM,CAKxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,WAChB,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAO1C,CAAC"}
+{"version":3,"file":"StringX.d.ts","sourceRoot":"","sources":["../src/StringX.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,WACV,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAC0B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,OAAO,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACjD,MAAM,SAAS,MAAM,OAAO,MAAM,KAAK,MAAM,CAKxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,WAChB,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACpC,MAAM,SAAS,MAAM,KAAK,MAAM,CAO1C,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB,eAEd,MAAM,WACR,MAAM,eACF,SAAS,MAAM,EAAE,KAC3B,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eAErB,MAAM,aACJ,MAAM,WACR,MAAM,eACF,SAAS,MAAM,EAAE,KAC3B,MAAM,CAmBZ,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,gBAAgB,iBAEZ,MAAM,SACZ,SAAS,MAAM,EAAE,KACrB,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,eACtB,MAAM,eAAe,MAAM,SAAS,SAAS,MAAM,EAAE,KAAK,MAAM,CAc3E,CAAC"}

package/dist/StringX.js

@@ -3,6 +3,7 @@
  *
  * @since 0.0.0
  */
+import { Array } from "effect";
 import { dual } from "effect/Function";
 /**
  * Prepends `start` to `string_`.
@@ -78,4 +79,71 @@ export const ensurePrepend = /*#__PURE__*/dual(2, (string_, start) => {
   }
   return `${start}${string_}`;
 });
+/**
+ * Replaces the inclusive line range `[startLine, endLine]` of `content` with
+ * `replacement` lines, returning the rejoined string.
+ *
+ * `content` is split on `\n`; the zero-based lines `startLine` through `endLine`
+ * (both inclusive) are dropped and `replacement` is spliced into their place.
+ * Pass an empty `replacement` to delete the range. Indices clamp naturally via
+ * `Array.take`/`Array.drop`, so out-of-range values don't throw.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — replace lines 1..2 with a single line
+ * assert.deepStrictEqual(
+ *   StringX.replaceLineRange("a\nb\nc\nd", 1, 2, ["X"]),
+ *   "a\nX\nd",
+ * )
+ *
+ * // an empty replacement deletes the range
+ * assert.deepStrictEqual(StringX.replaceLineRange("a\nb\nc\nd", 1, 2, []), "a\nd")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(
+ *   pipe("a\nb\nc", StringX.replaceLineRange(1, 1, ["X", "Y"])),
+ *   "a\nX\nY\nc",
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const replaceLineRange = /*#__PURE__*/dual(4, (content, startLine, endLine, replacement) => {
+  const lines = content.split("\n");
+  return Array.join([...Array.take(lines, startLine), ...replacement, ...Array.drop(lines, endLine + 1)], "\n");
+});
+/**
+ * Inserts `lines` immediately before the line at `anchorIndex`, preserving the
+ * anchor line and everything after it; returns the rejoined string.
+ *
+ * `content` is split on `\n` and `lines` are spliced in just before the
+ * zero-based `anchorIndex`. An `anchorIndex` of `0` prepends, and one at or past
+ * the end appends.
+ *
+ * @example
+ * ```ts
+ * import { pipe } from "effect"
+ * import { StringX } from "@nunofyobiz/effect-extras"
+ *
+ * // data-first — insert before line 1, keeping the anchor and the rest
+ * assert.deepStrictEqual(StringX.insertBeforeLine("a\nb\nc", 1, ["X"]), "a\nX\nb\nc")
+ *
+ * // an anchor at the end appends
+ * assert.deepStrictEqual(StringX.insertBeforeLine("a\nb", 2, ["X"]), "a\nb\nX")
+ *
+ * // data-last (piped)
+ * assert.deepStrictEqual(pipe("a\nb", StringX.insertBeforeLine(0, ["X"])), "X\na\nb")
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export const insertBeforeLine = /*#__PURE__*/dual(3, (content, anchorIndex, lines) => {
+  const split = content.split("\n");
+  return Array.join([...Array.take(split, anchorIndex), ...lines, ...Array.drop(split, anchorIndex)], "\n");
+});
 //# sourceMappingURL=StringX.js.map

package/dist/StringX.js.map

@@ -1 +1 @@
-{"version":3,"file":"StringX.js","names":["dual","prepend","string_","start","surround","end","ensurePrepend","startsWith"],"sources":["../src/StringX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,OAAO,gBAAGD,IAAI,CAGzB,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAa,GAAGA,KAAK,GAAGD,OAAO,EAAE,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAME,QAAQ,gBAAGJ,IAAI,CAI1B,CAAC,EACD,CAACE,OAAe,EAAEC,KAAa,EAAEE,GAAW,KAC1C,GAAGF,KAAK,GAAGD,OAAO,GAAGG,GAAG,EAAE,CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,aAAa,gBAAGN,IAAI,CAG/B,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAY;EAC9C,IAAID,OAAO,CAACK,UAAU,CAACJ,KAAK,CAAC,EAAE;IAC7B,OAAOD,OAAO;EAChB;EAEA,OAAO,GAAGC,KAAK,GAAGD,OAAO,EAAE;AAC7B,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"StringX.js","names":["Array","dual","prepend","string_","start","surround","end","ensurePrepend","startsWith","replaceLineRange","content","startLine","endLine","replacement","lines","split","join","take","drop","insertBeforeLine","anchorIndex"],"sources":["../src/StringX.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;AAKA,SAASA,KAAK,QAAQ,QAAQ;AAC9B,SAASC,IAAI,QAAQ,iBAAiB;AAEtC;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,OAAO,gBAAGD,IAAI,CAGzB,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAa,GAAGA,KAAK,GAAGD,OAAO,EAAE,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAME,QAAQ,gBAAGJ,IAAI,CAI1B,CAAC,EACD,CAACE,OAAe,EAAEC,KAAa,EAAEE,GAAW,KAC1C,GAAGF,KAAK,GAAGD,OAAO,GAAGG,GAAG,EAAE,CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,MAAMC,aAAa,gBAAGN,IAAI,CAG/B,CAAC,EAAE,CAACE,OAAe,EAAEC,KAAa,KAAY;EAC9C,IAAID,OAAO,CAACK,UAAU,CAACJ,KAAK,CAAC,EAAE;IAC7B,OAAOD,OAAO;EAChB;EAEA,OAAO,GAAGC,KAAK,GAAGD,OAAO,EAAE;AAC7B,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,OAAO,MAAMM,gBAAgB,gBAAGR,IAAI,CAalC,CAAC,EACD,CACES,OAAe,EACfC,SAAiB,EACjBC,OAAe,EACfC,WAA8B,KACpB;EACV,MAAMC,KAAK,GAAGJ,OAAO,CAACK,KAAK,CAAC,IAAI,CAAC;EACjC,OAAOf,KAAK,CAACgB,IAAI,CACf,CACE,GAAGhB,KAAK,CAACiB,IAAI,CAACH,KAAK,EAAEH,SAAS,CAAC,EAC/B,GAAGE,WAAW,EACd,GAAGb,KAAK,CAACkB,IAAI,CAACJ,KAAK,EAAEF,OAAO,GAAG,CAAC,CAAC,CAClC,EACD,IAAI,CACL;AACH,CAAC,CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMO,gBAAgB,gBAAGlB,IAAI,CAOlC,CAAC,EACD,CAACS,OAAe,EAAEU,WAAmB,EAAEN,KAAwB,KAAY;EACzE,MAAMC,KAAK,GAAGL,OAAO,CAACK,KAAK,CAAC,IAAI,CAAC;EACjC,OAAOf,KAAK,CAACgB,IAAI,CACf,CACE,GAAGhB,KAAK,CAACiB,IAAI,CAACF,KAAK,EAAEK,WAAW,CAAC,EACjC,GAAGN,KAAK,EACR,GAAGd,KAAK,CAACkB,IAAI,CAACH,KAAK,EAAEK,WAAW,CAAC,CAClC,EACD,IAAI,CACL;AACH,CAAC,CACF","ignoreList":[]}

package/dist/WarnResult.d.ts

@@ -21,7 +21,7 @@ import { Data, Effect, Option } from "effect";
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const both: WarnResult.WarnResult<string, number> =
+ * const both: WarnResult.WarnResult<number, string> =
  *   WarnResult.SuccessWithWarnings({
  *     warnings: "rounded down",
  *     success: 1
@@ -33,7 +33,7 @@ import { Data, Effect, Option } from "effect";
  * @category models
  * @since 0.0.0
  */
-export type WarnResult<W, A> = Data.TaggedEnum<{
+export type WarnResult<A, W> = Data.TaggedEnum<{
     WarningsOnly: {
         readonly warnings: W;
     };
@@ -63,7 +63,7 @@ export type WarnResult<W, A> = Data.TaggedEnum<{
  * @category models
  * @since 0.0.0
  */
-export type WarningsOnly<W> = WarnResult<W, never> & {
+export type WarningsOnly<W> = WarnResult<never, W> & {
     _tag: "WarningsOnly";
 };
 /**
@@ -84,7 +84,7 @@ export type WarningsOnly<W> = WarnResult<W, never> & {
  * @category models
  * @since 0.0.0
  */
-export type SuccessOnly<A> = WarnResult<never, A> & {
+export type SuccessOnly<A> = WarnResult<A, never> & {
     _tag: "SuccessOnly";
 };
 /**
@@ -95,7 +95,7 @@ export type SuccessOnly<A> = WarnResult<never, A> & {
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.SuccessWithWarnings<string, number> =
+ * const value: WarnResult.SuccessWithWarnings<number, string> =
  *   WarnResult.SuccessWithWarnings({
  *     warnings: "rounded down",
  *     success: 1
@@ -111,7 +111,7 @@ export type SuccessOnly<A> = WarnResult<never, A> & {
  * @category models
  * @since 0.0.0
  */
-export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
+export type SuccessWithWarnings<A, W> = WarnResult<A, W> & {
     _tag: "SuccessWithWarnings";
 };
 /**
@@ -122,7 +122,7 @@ export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.WithWarnings<string, number> = WarnResult.WarningsOnly({
+ * const value: WarnResult.WithWarnings<number, string> = WarnResult.WarningsOnly({
  *   warnings: "skipped 2 rows"
  * })
  *
@@ -132,7 +132,7 @@ export type SuccessWithWarnings<W, A> = WarnResult<W, A> & {
  * @category models
  * @since 0.0.0
  */
-export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
+export type WithWarnings<A, W> = WarningsOnly<W> | SuccessWithWarnings<A, W>;
 /**
  * Any `WarnResult` that is guaranteed to carry a `success` value — either
  * `SuccessOnly` or `SuccessWithWarnings`.
@@ -141,7 +141,7 @@ export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
  * ```ts
  * import { WarnResult } from "@nunofyobiz/effect-extras"
  *
- * const value: WarnResult.WithSuccess<string, number> = WarnResult.SuccessOnly({
+ * const value: WarnResult.WithSuccess<number, string> = WarnResult.SuccessOnly({
  *   success: 1
  * })
  *
@@ -151,7 +151,7 @@ export type WithWarnings<W, A> = WarningsOnly<W> | SuccessWithWarnings<W, A>;
  * @category models
  * @since 0.0.0
  */
-export type WithSuccess<W, A> = SuccessOnly<A> | SuccessWithWarnings<W, A>;
+export type WithSuccess<A, W> = SuccessOnly<A> | SuccessWithWarnings<A, W>;
 /**
  * Constructs a `WarningsOnly` — a `WarnResult` that carries only `warnings`.
  *
@@ -169,10 +169,10 @@ export type WithSuccess<W, A> = SuccessOnly<A> | SuccessWithWarnings<W, A>;
  * @since 0.0.0
  */
 export declare const WarningsOnly: <A, B>(args: {
-    readonly warnings: A;
+    readonly warnings: B;
 }) => {
     readonly _tag: "WarningsOnly";
-    readonly warnings: A;
+    readonly warnings: B;
 };
 /**
  * Constructs a `SuccessOnly` — a `WarnResult` that carries only a `success` value.
@@ -191,10 +191,10 @@ export declare const WarningsOnly: <A, B>(args: {
  * @since 0.0.0
  */
 export declare const SuccessOnly: <A, B>(args: {
-    readonly success: B;
+    readonly success: A;
 }) => {
     readonly _tag: "SuccessOnly";
-    readonly success: B;
+    readonly success: A;
 };
 /**
  * Constructs a `SuccessWithWarnings` — a `WarnResult` that carries both a
@@ -218,12 +218,12 @@ export declare const SuccessOnly: <A, B>(args: {
  * @since 0.0.0
  */
 export declare const SuccessWithWarnings: <A, B>(args: {
-    readonly warnings: A;
-    readonly success: B;
+    readonly warnings: B;
+    readonly success: A;
 }) => {
     readonly _tag: "SuccessWithWarnings";
-    readonly warnings: A;
-    readonly success: B;
+    readonly warnings: B;
+    readonly success: A;
 };
 /**
  * Builds per-tag refinements for `WarnResult`. `is("WarningsOnly")` is a type
@@ -307,52 +307,52 @@ export declare const match: {
     <A, B, C, D, Cases extends {
         readonly WarningsOnly: (args: {
             readonly _tag: "WarningsOnly";
-            readonly warnings: A;
+            readonly warnings: B;
         }) => any;
         readonly SuccessOnly: (args: {
             readonly _tag: "SuccessOnly";
-            readonly success: B;
+            readonly success: A;
         }) => any;
         readonly SuccessWithWarnings: (args: {
             readonly _tag: "SuccessWithWarnings";
-            readonly warnings: A;
-            readonly success: B;
+            readonly warnings: B;
+            readonly success: A;
         }) => any;
     }>(cases: Cases): (self: {
         readonly _tag: "WarningsOnly";
-        readonly warnings: A;
+        readonly warnings: B;
     } | {
         readonly _tag: "SuccessOnly";
-        readonly success: B;
+        readonly success: A;
     } | {
         readonly _tag: "SuccessWithWarnings";
-        readonly warnings: A;
-        readonly success: B;
+        readonly warnings: B;
+        readonly success: A;
     }) => import("effect/Unify").Unify<ReturnType<Cases["WarningsOnly" | "SuccessOnly" | "SuccessWithWarnings"]>>;
     <A, B, C, D, Cases extends {
         readonly WarningsOnly: (args: {
             readonly _tag: "WarningsOnly";
-            readonly warnings: A;
+            readonly warnings: B;
         }) => any;
         readonly SuccessOnly: (args: {
             readonly _tag: "SuccessOnly";
-            readonly success: B;
+            readonly success: A;
         }) => any;
         readonly SuccessWithWarnings: (args: {
             readonly _tag: "SuccessWithWarnings";
-            readonly warnings: A;
-            readonly success: B;
+            readonly warnings: B;
+            readonly success: A;
         }) => any;
     }>(self: {
         readonly _tag: "WarningsOnly";
-        readonly warnings: A;
+        readonly warnings: B;
     } | {
         readonly _tag: "SuccessOnly";
-        readonly success: B;
+        readonly success: A;
     } | {
         readonly _tag: "SuccessWithWarnings";
-        readonly warnings: A;
-        readonly success: B;
+        readonly warnings: B;
+        readonly success: A;
     }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["WarningsOnly" | "SuccessOnly" | "SuccessWithWarnings"]>>;
 };
 /**
@@ -362,7 +362,7 @@ export declare const match: {
  * Use it when the `warnings` are mandatory and the `success` value is an optional
  * companion: pass an absent (`null`/`undefined`) `success` to get a
  * `WarningsOnly`, or a present one to get a `SuccessWithWarnings`. The return type
- * `WithWarnings<W, A>` reflects that `warnings` are always present.
+ * `WithWarnings<A, W>` reflects that `warnings` are always present.
  *
  * @example
  * ```ts
@@ -382,10 +382,10 @@ export declare const match: {
  * @category constructors
  * @since 0.0.0
  */
-export declare const WithWarnings: <W, A>({ warnings, success, }: {
+export declare const WithWarnings: <A, W>({ warnings, success, }: {
     warnings: W;
     success?: A | undefined;
-}) => WithWarnings<W, A>;
+}) => WithWarnings<A, W>;
 /**
  * Builds a `WarnResult` known to carry a `success` value, choosing
  * `SuccessWithWarnings` when `warnings` are present and `SuccessOnly` otherwise.
@@ -393,7 +393,7 @@ export declare const WithWarnings: <W, A>({ warnings, success, }: {
  * The mirror of `WithWarnings`: the `success` value is mandatory and the
  * `warnings` are an optional companion. Pass absent (`null`/`undefined`)
  * `warnings` to get a `SuccessOnly`, or present ones to get a
- * `SuccessWithWarnings`. The return type `WithSuccess<W, A>` reflects that a
+ * `SuccessWithWarnings`. The return type `WithSuccess<A, W>` reflects that a
  * `success` value is always present.
  *
  * @example
@@ -414,10 +414,10 @@ export declare const WithWarnings: <W, A>({ warnings, success, }: {
  * @category constructors
  * @since 0.0.0
  */
-export declare const WithSuccess: <W, A>({ warnings, success, }: {
+export declare const WithSuccess: <A, W>({ warnings, success, }: {
     warnings?: W | undefined;
     success: A;
-}) => WithSuccess<W, A>;
+}) => WithSuccess<A, W>;
 /**
  * Builds a `WarnResult` from a pair of possibly-nullish inputs, wrapping the
  * result in an `Option` so the all-absent case is expressible.
@@ -452,10 +452,10 @@ export declare const WithSuccess: <W, A>({ warnings, success, }: {
  * @category constructors
  * @since 0.0.0
  */
-export declare const optionFromNullables: <W, A>({ warnings, success, }: {
+export declare const optionFromNullables: <A, W>({ warnings, success, }: {
     warnings?: W | null | undefined;
     success?: A | null | undefined;
-}) => Option.Option<WarnResult<W, A>>;
+}) => Option.Option<WarnResult<A, W>>;
 /**
  * Builds a `WarnResult` from a pair of possibly-nullish inputs, falling back to
  * the `orElse` thunk when both are absent.
@@ -488,11 +488,11 @@ export declare const optionFromNullables: <W, A>({ warnings, success, }: {
  * @category constructors
  * @since 0.0.0
  */
-export declare const fromNullables: <W, A>({ warnings, success, orElse, }: {
+export declare const fromNullables: <A, W>({ warnings, success, orElse, }: {
     warnings?: W | null | undefined;
     success?: A | null | undefined;
-    orElse?: () => WarnResult<W, A>;
-}) => WarnResult<W, A>;
+    orElse?: () => WarnResult<A, W>;
+}) => WarnResult<A, W>;
 /**
  * Folds a `WarnResult` from the warnings' perspective, collapsing the three tags
  * into two handlers.
@@ -528,10 +528,10 @@ export declare const fromNullables: <W, A>({ warnings, success, orElse, }: {
  * @category pattern matching
  * @since 0.0.0
  */
-export declare const matchWarnings: <W, A, Z>({ Warnings, SuccessOnly, }: {
+export declare const matchWarnings: <A, W, Z>({ Warnings, SuccessOnly, }: {
     Warnings: (warnings: W) => Z;
     SuccessOnly: (success: A) => Z;
-}) => (warnResult: WarnResult<W, A>) => Z;
+}) => (warnResult: WarnResult<A, W>) => Z;
 /**
  * Folds a `WarnResult` from the success value's perspective, collapsing the three
  * tags into two handlers.
@@ -568,10 +568,10 @@ export declare const matchWarnings: <W, A, Z>({ Warnings, SuccessOnly, }: {
  * @category pattern matching
  * @since 0.0.0
  */
-export declare const matchSuccess: <W, A, Z>({ WarningsOnly, Success, }: {
+export declare const matchSuccess: <A, W, Z>({ WarningsOnly, Success, }: {
     WarningsOnly: (warnings: W) => Z;
     Success: (success: A) => Z;
-}) => (warnResult: WarnResult<W, A>) => Z;
+}) => (warnResult: WarnResult<A, W>) => Z;
 /**
  * Completes a `WarnResult` into a guaranteed `SuccessWithWarnings` by filling
  * whichever side is missing from the matching `orElse` thunk.
@@ -603,10 +603,10 @@ export declare const matchSuccess: <W, A, Z>({ WarningsOnly, Success, }: {
  * @category getters
  * @since 0.0.0
  */
-export declare const orElse: <W2, A2>({ orElseWarnings, orElseSuccess, }: {
+export declare const orElse: <A2, W2>({ orElseWarnings, orElseSuccess, }: {
     orElseWarnings: () => W2;
     orElseSuccess: () => A2;
-}) => (<W, A>(warnResult: WarnResult<W, A>) => SuccessWithWarnings<W | W2, A | A2>);
+}) => (<A, W>(warnResult: WarnResult<A, W>) => SuccessWithWarnings<A | A2, W | W2>);
 /**
  * Completes a `WarnResult` into a `SuccessWithWarnings` whose missing side is
  * filled with `undefined`.
@@ -633,7 +633,7 @@ export declare const orElse: <W2, A2>({ orElseWarnings, orElseSuccess, }: {
  * @category getters
  * @since 0.0.0
  */
-export declare const orUndefined: <W, A>(warnResult: {
+export declare const orUndefined: <A, W>(warnResult: {
     readonly _tag: "WarningsOnly";
     readonly warnings: W;
 } | {
@@ -681,7 +681,7 @@ export declare const orUndefined: <W, A>(warnResult: {
  * @category getters
  * @since 0.0.0
  */
-export declare const warningsOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnResult: WarnResult<W, A>) => W | Z;
+export declare const warningsOrElse: <Z>(orElseReturn: () => Z) => <A, W>(warnResult: WarnResult<A, W>) => W | Z;
 /**
  * Extracts the `warnings` of a `WarnResult`, returning `undefined` when no
  * `warnings` are present.
@@ -707,7 +707,7 @@ export declare const warningsOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnRe
  * @category getters
  * @since 0.0.0
  */
-export declare const warningsOrUndefined: <W, A>(warnResult: {
+export declare const warningsOrUndefined: <A, W>(warnResult: {
     readonly _tag: "WarningsOnly";
     readonly warnings: W;
 } | {
@@ -744,7 +744,7 @@ export declare const warningsOrUndefined: <W, A>(warnResult: {
  * @category getters
  * @since 0.0.0
  */
-export declare const successOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnResult: WarnResult<W, A>) => A | Z;
+export declare const successOrElse: <Z>(orElseReturn: () => Z) => <A, W>(warnResult: WarnResult<A, W>) => A | Z;
 /**
  * Extracts the `success` value of a `WarnResult`, returning `undefined` when no
  * `success` value is present.
@@ -770,7 +770,7 @@ export declare const successOrElse: <Z>(orElseReturn: () => Z) => <W, A>(warnRes
  * @category getters
  * @since 0.0.0
  */
-export declare const successOrUndefined: <W, A>(warnResult: {
+export declare const successOrUndefined: <A, W>(warnResult: {
     readonly _tag: "WarningsOnly";
     readonly warnings: W;
 } | {
@@ -806,7 +806,7 @@ export declare const successOrUndefined: <W, A>(warnResult: {
  * @category getters
  * @since 0.0.0
  */
-export declare const successOption: <W, A>(warnResult: WarnResult<W, A>) => Option.Option<A>;
+export declare const successOption: <A, W>(warnResult: WarnResult<A, W>) => Option.Option<A>;
 /**
  * Extracts the `warnings` of a `WarnResult` as an `Option`.
  *
@@ -831,7 +831,7 @@ export declare const successOption: <W, A>(warnResult: WarnResult<W, A>) => Opti
  * @category getters
  * @since 0.0.0
  */
-export declare const warningsOption: <W, A>(warnResult: WarnResult<W, A>) => Option.Option<W>;
+export declare const warningsOption: <A, W>(warnResult: WarnResult<A, W>) => Option.Option<W>;
 /**
  * Transforms both sides of a `WarnResult`, applying `mapWarnings` to any
  * `warnings` and `mapSuccess` to any `success` value.
@@ -863,10 +863,10 @@ export declare const warningsOption: <W, A>(warnResult: WarnResult<W, A>) => Opt
  * @category mapping
  * @since 0.0.0
  */
-export declare const mapBoth: <W1, A1, W2, A2>({ mapWarnings, mapSuccess, }: {
+export declare const mapBoth: <A1, W1, A2, W2>({ mapWarnings, mapSuccess, }: {
     mapWarnings: (warnings: W1) => W2;
     mapSuccess: (success: A1) => A2;
-}) => ((warnResult: WarnResult<W1, A1>) => WarnResult<W2, A2>);
+}) => ((warnResult: WarnResult<A1, W1>) => WarnResult<A2, W2>);
 /**
  * Effectful `mapBoth`: transforms each present side through an `Effect`,
  * reassembling the results into a `WarnResult` inside an `Effect`.
@@ -897,10 +897,10 @@ export declare const mapBoth: <W1, A1, W2, A2>({ mapWarnings, mapSuccess, }: {
  * @category sequencing
  * @since 0.0.0
  */
-export declare const mapBothEffect: <W1, A1, W2, A2, EW, EA, RW, RA>({ mapWarnings, mapSuccess, }: {
+export declare const mapBothEffect: <A1, W1, A2, W2, EA, EW, RA, RW>({ mapWarnings, mapSuccess, }: {
     mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>;
     mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>;
-}) => ((warnResult: WarnResult<W1, A1>) => Effect.Effect<WarnResult<W2, A2>, EW | EA, RW | RA>);
+}) => ((warnResult: WarnResult<A1, W1>) => Effect.Effect<WarnResult<A2, W2>, EW | EA, RW | RA>);
 /**
  * Transforms the `warnings` of a `WarnResult`, leaving any `success` value
  * untouched.
@@ -930,7 +930,7 @@ export declare const mapBothEffect: <W1, A1, W2, A2, EW, EA, RW, RA>({ mapWarnin
  * @category mapping
  * @since 0.0.0
  */
-export declare const mapWarnings: <W1, W2>(mapWarnings: (warnings: W1) => W2) => (<A>(warnResult: WarnResult<W1, A>) => WarnResult<W2, A>);
+export declare const mapWarnings: <W1, W2>(mapWarnings: (warnings: W1) => W2) => (<A>(warnResult: WarnResult<A, W1>) => WarnResult<A, W2>);
 /**
  * Chains the `warnings` of a `WarnResult` into a new `WarnResult`, flattening the
  * result.
@@ -963,7 +963,7 @@ export declare const mapWarnings: <W1, W2>(mapWarnings: (warnings: W1) => W2) =>
  * @category sequencing
  * @since 0.0.0
  */
-export declare const flatMapWarnings: <W1, W2, A2>(mapWarnings: (warnings: W1) => WarnResult<W2, A2>) => (<A1>(warnResult: WarnResult<W1, A1>) => WarnResult<W2, A1 | A2>);
+export declare const flatMapWarnings: <A2, W1, W2>(mapWarnings: (warnings: W1) => WarnResult<A2, W2>) => (<A1>(warnResult: WarnResult<A1, W1>) => WarnResult<A1 | A2, W2>);
 /**
  * Effectful `mapWarnings`: transforms the `warnings` of a `WarnResult` through an
  * `Effect`, leaving any `success` value untouched.
@@ -992,7 +992,7 @@ export declare const flatMapWarnings: <W1, W2, A2>(mapWarnings: (warnings: W1) =
  * @category sequencing
  * @since 0.0.0
  */
-export 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>);
+export declare const mapWarningsEffect: <W1, W2, EW, RW>(mapWarnings: (warnings: W1) => Effect.Effect<W2, EW, RW>) => (<A>(warnResult: WarnResult<A, W1>) => Effect.Effect<WarnResult<A, W2>, EW, RW>);
 /**
  * Effectful `flatMapWarnings`: chains the `warnings` of a `WarnResult` into an
  * `Effect` that yields a new `WarnResult`, flattening the result.
@@ -1024,7 +1024,7 @@ export declare const mapWarningsEffect: <W1, W2, EW, RW>(mapWarnings: (warnings:
  * @category sequencing
  * @since 0.0.0
  */
-export 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>);
+export declare const flatMapWarningsEffect: <A2, W1, W2, EW, RW>(mapWarnings: (warnings: W1) => Effect.Effect<WarnResult<A2, W2>, EW, RW>) => (<A1>(warnResult: WarnResult<A1, W1>) => Effect.Effect<WarnResult<A1 | A2, W2>, EW, RW>);
 /**
  * Transforms the `success` value of a `WarnResult`, leaving any `warnings`
  * untouched.
@@ -1051,7 +1051,7 @@ export declare const flatMapWarningsEffect: <W1, W2, A2, EW, RW>(mapWarnings: (w
  * @category mapping
  * @since 0.0.0
  */
-export declare const mapSuccess: <A1, A2>(mapSuccess: (success: A1) => A2) => (<W>(warnResult: WarnResult<W, A1>) => WarnResult<W, A2>);
+export declare const mapSuccess: <A1, A2>(mapSuccess: (success: A1) => A2) => (<W>(warnResult: WarnResult<A1, W>) => WarnResult<A2, W>);
 /**
  * Chains the `success` value of a `WarnResult` into a new `WarnResult`, flattening
  * the result.
@@ -1082,7 +1082,7 @@ export declare const mapSuccess: <A1, A2>(mapSuccess: (success: A1) => A2) => (<
  * @category sequencing
  * @since 0.0.0
  */
-export declare const flatMapSuccess: <W2, A1, A2>(mapSuccess: (success: A1) => WarnResult<W2, A2>) => (<W1>(warnResult: WarnResult<W1, A1>) => WarnResult<W1 | W2, A2>);
+export declare const flatMapSuccess: <A1, A2, W2>(mapSuccess: (success: A1) => WarnResult<A2, W2>) => (<W1>(warnResult: WarnResult<A1, W1>) => WarnResult<A2, W1 | W2>);
 /**
  * Effectful `mapSuccess`: transforms the `success` value of a `WarnResult` through
  * an `Effect`, leaving any `warnings` untouched.
@@ -1111,7 +1111,7 @@ export declare const flatMapSuccess: <W2, A1, A2>(mapSuccess: (success: A1) => W
  * @category sequencing
  * @since 0.0.0
  */
-export 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>);
+export declare const mapSuccessEffect: <A1, A2, EA, RA>(mapSuccess: (success: A1) => Effect.Effect<A2, EA, RA>) => (<W>(warnResult: WarnResult<A1, W>) => Effect.Effect<WarnResult<A2, W>, EA, RA>);
 /**
  * Effectful `flatMapSuccess`: chains the `success` value of a `WarnResult` into an
  * `Effect` that yields a new `WarnResult`, flattening the result.
@@ -1142,5 +1142,50 @@ export declare const mapSuccessEffect: <A1, A2, EA, RA>(mapSuccess: (success: A1
  * @category sequencing
  * @since 0.0.0
  */
-export 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>);
+export declare const flatMapSuccessEffect: <A1, A2, W2, EA, RA>(mapSuccess: (success: A1) => Effect.Effect<WarnResult<A2, W2>, EA, RA>) => (<W1>(warnResult: WarnResult<A1, W1>) => Effect.Effect<WarnResult<A2, W1 | W2>, EA, RA>);
+/**
+ * Zips two arrays into one, calling `f` with a `WarnResult` for each index so
+ * that length mismatches are handled explicitly rather than truncated.
+ *
+ * Unlike `Array.zipWith` (which stops at the shorter array), this walks to the
+ * length of the *longer* array. The first array's element fills the `warnings`
+ * side and the second array's element fills the `success` side, so at each index
+ * `f` receives a `WarnResult.WarnResult<B, A>`: `SuccessWithWarnings` when both
+ * arrays have an element, `WarningsOnly` when only the first does, and
+ * `SuccessOnly` when only the second does. Use it when the "extra" tail of either
+ * array still carries meaning.
+ *
+ * @example
+ * ```ts
+ * import { WarnResult } from "@nunofyobiz/effect-extras"
+ * import { pipe } from "effect"
+ *
+ * const describe = WarnResult.match({
+ *   WarningsOnly: ({ warnings }) => `warnings ${warnings}`,
+ *   SuccessOnly: ({ success }) => `success ${success}`,
+ *   SuccessWithWarnings: ({ warnings, success }) => `both ${warnings}/${success}`
+ * })
+ *
+ * // data-first
+ * assert.deepStrictEqual(WarnResult.zip([1, 2, 3], [10, 20], describe), [
+ *   "both 1/10",
+ *   "both 2/20",
+ *   "warnings 3"
+ * ])
+ *
+ * // data-last (pipeable)
+ * assert.deepStrictEqual(pipe([1, 2, 3], WarnResult.zip([10, 20], describe)), [
+ *   "both 1/10",
+ *   "both 2/20",
+ *   "warnings 3"
+ * ])
+ * ```
+ *
+ * @category combinators
+ * @since 0.0.0
+ */
+export declare const zip: {
+    <A, B, C>(array2: readonly B[], f: (warnResult: WarnResult<B, A>) => C): (array1: readonly A[]) => C[];
+    <A, B, C>(array1: readonly A[], array2: readonly B[], f: (warnResult: WarnResult<B, A>) => C): C[];
+};
 //# sourceMappingURL=WarnResult.d.ts.map