@nicolastoulemont/std 0.6.0 → 0.7.1

package/dist/{index-CklRfom5.d.mts → index-B1-tBzc0.d.mts}

@@ -1,7 +1,7 @@
-import { i as Fx } from "./fx.types-B34asVRX.mjs";
-import { t as Pipeable } from "./pipeable-B4YJA56p.mjs";
-import { t as Result } from "./result.types-HHDzgSTV.mjs";
-import { r as Option } from "./option.types-ClJiBTdg.mjs";
+import { i as Fx } from "./fx.types-DeEWEltG.mjs";
+import { t as Pipeable } from "./pipeable-rfqacPxZ.mjs";
+import { t as Result } from "./result.types-_xDAei3-.mjs";
+import { r as Option } from "./option.types-qPevEZQd.mjs";
 
 //#region src/either/either.types.d.ts
 /**
@@ -70,53 +70,17 @@ type RightValue<E> = E extends {
   readonly _tag: "Right";
   readonly value: infer R;
 } ? R : never;
-/**
- * Return type for map() - detects Promise and adjusts return type
- */
-type MapReturn<FnReturn, L> = FnReturn extends Promise<infer U> ? Promise<Either$1<L, U>> : Either$1<L, FnReturn>;
-/**
- * Return type for mapLeft() - detects Promise and adjusts return type
- */
-type MapLeftReturn<R, FnReturn> = FnReturn extends Promise<infer L2> ? Promise<Either$1<L2, R>> : Either$1<FnReturn, R>;
-/**
- * Return type for bimap() - detects Promise and adjusts return type
- */
-type BimapReturn<FnLeftReturn, FnRightReturn> = FnLeftReturn | FnRightReturn extends Promise<any> ? Promise<FnLeftReturn extends Promise<Either$1<infer L2, any>> ? Either$1<L2, any> : FnLeftReturn extends Either$1<infer L2, any> ? Either$1<L2, any> : FnRightReturn extends Promise<Either$1<any, infer R2>> ? Either$1<any, R2> : FnRightReturn extends Either$1<any, infer R2> ? Either$1<any, R2> : never> : FnLeftReturn extends Either$1<infer L2, any> ? FnRightReturn extends Either$1<any, infer R2> ? Either$1<L2, R2> : never : never;
-/**
- * Return type for flatMap() - combines left error unions
- */
-type FlatMapReturn<FnReturn, L> = FnReturn extends Promise<Either$1<infer L2, infer R2>> ? Promise<Either$1<L | L2, R2>> : FnReturn extends Either$1<infer L2, infer R2> ? Either$1<L | L2, R2> : never;
-/**
- * Return type for tap() - preserves Either type with async detection
- */
-type TapReturn<FnReturn, L, R> = FnReturn extends Promise<any> ? Promise<Either$1<L, R>> : Either$1<L, R>;
-/**
- * Return type for orElse() - combines right value unions
- */
-type OrElseReturn<FnReturn, R> = FnReturn extends Promise<Either$1<infer L2, infer R2>> ? Promise<Either$1<L2, R | R2>> : FnReturn extends Either$1<infer L2, infer R2> ? Either$1<L2, R | R2> : never;
-/**
- * Return type for filter() - adds L2 to left union
- */
-type FilterReturn<L, L2$1, R> = Either$1<L | L2$1, R>;
-/**
- * Return type for all() with array input - preserves tuple structure
- */
-type AllArrayReturn<T extends readonly Either$1<unknown, unknown>[]> = Either$1<LeftValue<T[number]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
-/**
- * Return type for all() with object input - preserves object structure
- */
-type AllObjectReturn<T extends Record<string, Either$1<unknown, unknown>>> = Either$1<LeftValue<T[keyof T]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
 /**
  * Overloaded all() type with explicit tuple arities for better inference.
  * Provides tuple overloads for 1-6 elements so `as const` is not required.
  */
 type EitherAll = {
   <L1, A>(eithers: readonly [Either$1<L1, A>]): Either$1<L1, [A]>;
-  <L1, L2$1, A, B>(eithers: readonly [Either$1<L1, A>, Either$1<L2$1, B>]): Either$1<L1 | L2$1, [A, B]>;
-  <L1, L2$1, L3, A, B, C>(eithers: readonly [Either$1<L1, A>, Either$1<L2$1, B>, Either$1<L3, C>]): Either$1<L1 | L2$1 | L3, [A, B, C]>;
-  <L1, L2$1, L3, L4, A, B, C, D>(eithers: readonly [Either$1<L1, A>, Either$1<L2$1, B>, Either$1<L3, C>, Either$1<L4, D>]): Either$1<L1 | L2$1 | L3 | L4, [A, B, C, D]>;
-  <L1, L2$1, L3, L4, L5, A, B, C, D, E>(eithers: readonly [Either$1<L1, A>, Either$1<L2$1, B>, Either$1<L3, C>, Either$1<L4, D>, Either$1<L5, E>]): Either$1<L1 | L2$1 | L3 | L4 | L5, [A, B, C, D, E]>;
-  <L1, L2$1, L3, L4, L5, L6, A, B, C, D, E, F>(eithers: readonly [Either$1<L1, A>, Either$1<L2$1, B>, Either$1<L3, C>, Either$1<L4, D>, Either$1<L5, E>, Either$1<L6, F>]): Either$1<L1 | L2$1 | L3 | L4 | L5 | L6, [A, B, C, D, E, F]>;
+  <L1, L2, A, B>(eithers: readonly [Either$1<L1, A>, Either$1<L2, B>]): Either$1<L1 | L2, [A, B]>;
+  <L1, L2, L3, A, B, C>(eithers: readonly [Either$1<L1, A>, Either$1<L2, B>, Either$1<L3, C>]): Either$1<L1 | L2 | L3, [A, B, C]>;
+  <L1, L2, L3, L4, A, B, C, D>(eithers: readonly [Either$1<L1, A>, Either$1<L2, B>, Either$1<L3, C>, Either$1<L4, D>]): Either$1<L1 | L2 | L3 | L4, [A, B, C, D]>;
+  <L1, L2, L3, L4, L5, A, B, C, D, E>(eithers: readonly [Either$1<L1, A>, Either$1<L2, B>, Either$1<L3, C>, Either$1<L4, D>, Either$1<L5, E>]): Either$1<L1 | L2 | L3 | L4 | L5, [A, B, C, D, E]>;
+  <L1, L2, L3, L4, L5, L6, A, B, C, D, E, F>(eithers: readonly [Either$1<L1, A>, Either$1<L2, B>, Either$1<L3, C>, Either$1<L4, D>, Either$1<L5, E>, Either$1<L6, F>]): Either$1<L1 | L2 | L3 | L4 | L5 | L6, [A, B, C, D, E, F]>;
   <T extends readonly Either$1<unknown, unknown>[]>(eithers: T): Either$1<LeftValue<T[number]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
   <T extends Record<string, Either$1<unknown, unknown>>>(eithers: T): Either$1<LeftValue<T[keyof T]>, { -readonly [K in keyof T]: RightValue<T[K]> }>;
 };
@@ -136,34 +100,34 @@ type EitherMap = {
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherMapLeft = {
-  <L1, R, L2$1>(either: Either$1<L1, R>, fn: (value: L1) => Promise<L2$1>): Promise<Either$1<L2$1, R>>;
-  <L1, R, L2$1>(either: Either$1<L1, R>, fn: (value: L1) => L2$1): Either$1<L2$1, R>;
-  <L1, L2$1>(fn: (value: L1) => Promise<L2$1>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R>>;
-  <L1, L2$1>(fn: (value: L1) => L2$1): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R>;
+  <L1, R, L2>(either: Either$1<L1, R>, fn: (value: L1) => Promise<L2>): Promise<Either$1<L2, R>>;
+  <L1, R, L2>(either: Either$1<L1, R>, fn: (value: L1) => L2): Either$1<L2, R>;
+  <L1, L2>(fn: (value: L1) => Promise<L2>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2, R>>;
+  <L1, L2>(fn: (value: L1) => L2): <R>(either: Either$1<L1, R>) => Either$1<L2, R>;
 };
 /**
  * Type-safe interface for bimap() with async detection
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherBimap = {
-  <L1, R1, L2$1, R2$1>(either: Either$1<L1, R1>, fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => Promise<R2$1>): Promise<Either$1<L2$1, R2$1>>;
-  <L1, R1, L2$1, R2$1>(either: Either$1<L1, R1>, fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => R2$1): Promise<Either$1<L2$1, R2$1>>;
-  <L1, R1, L2$1, R2$1>(either: Either$1<L1, R1>, fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => Promise<R2$1>): Promise<Either$1<L2$1, R2$1>>;
-  <L1, R1, L2$1, R2$1>(either: Either$1<L1, R1>, fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => R2$1): Either$1<L2$1, R2$1>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => Promise<L2$1>, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => Promise<R2$1>): (either: Either$1<L1, R1>) => Promise<Either$1<L2$1, R2$1>>;
-  <L1, L2$1, R1, R2$1>(fnLeft: (left: L1) => L2$1, fnRight: (right: R1) => R2$1): (either: Either$1<L1, R1>) => Either$1<L2$1, R2$1>;
+  <L1, R1, L2, R2>(either: Either$1<L1, R1>, fnLeft: (left: L1) => Promise<L2>, fnRight: (right: R1) => Promise<R2>): Promise<Either$1<L2, R2>>;
+  <L1, R1, L2, R2>(either: Either$1<L1, R1>, fnLeft: (left: L1) => Promise<L2>, fnRight: (right: R1) => R2): Promise<Either$1<L2, R2>>;
+  <L1, R1, L2, R2>(either: Either$1<L1, R1>, fnLeft: (left: L1) => L2, fnRight: (right: R1) => Promise<R2>): Promise<Either$1<L2, R2>>;
+  <L1, R1, L2, R2>(either: Either$1<L1, R1>, fnLeft: (left: L1) => L2, fnRight: (right: R1) => R2): Either$1<L2, R2>;
+  <L1, L2, R1, R2>(fnLeft: (left: L1) => Promise<L2>, fnRight: (right: R1) => Promise<R2>): (either: Either$1<L1, R1>) => Promise<Either$1<L2, R2>>;
+  <L1, L2, R1, R2>(fnLeft: (left: L1) => Promise<L2>, fnRight: (right: R1) => R2): (either: Either$1<L1, R1>) => Promise<Either$1<L2, R2>>;
+  <L1, L2, R1, R2>(fnLeft: (left: L1) => L2, fnRight: (right: R1) => Promise<R2>): (either: Either$1<L1, R1>) => Promise<Either$1<L2, R2>>;
+  <L1, L2, R1, R2>(fnLeft: (left: L1) => L2, fnRight: (right: R1) => R2): (either: Either$1<L1, R1>) => Either$1<L2, R2>;
 };
 /**
  * Type-safe interface for flatMap() with async detection and left union
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherFlatMap = {
-  <L, A, B, L2$1>(either: Either$1<L, A>, fn: (value: A) => Promise<Either$1<L2$1, B>>): Promise<Either$1<L | L2$1, B>>;
-  <L, A, B, L2$1>(either: Either$1<L, A>, fn: (value: A) => Either$1<L2$1, B>): Either$1<L | L2$1, B>;
-  <A, B, L2$1>(fn: (value: A) => Promise<Either$1<L2$1, B>>): <L>(either: Either$1<L, A>) => Promise<Either$1<L | L2$1, B>>;
-  <A, B, L2$1>(fn: (value: A) => Either$1<L2$1, B>): <L>(either: Either$1<L, A>) => Either$1<L | L2$1, B>;
+  <L, A, B, L2>(either: Either$1<L, A>, fn: (value: A) => Promise<Either$1<L2, B>>): Promise<Either$1<L | L2, B>>;
+  <L, A, B, L2>(either: Either$1<L, A>, fn: (value: A) => Either$1<L2, B>): Either$1<L | L2, B>;
+  <A, B, L2>(fn: (value: A) => Promise<Either$1<L2, B>>): <L>(either: Either$1<L, A>) => Promise<Either$1<L | L2, B>>;
+  <A, B, L2>(fn: (value: A) => Either$1<L2, B>): <L>(either: Either$1<L, A>) => Either$1<L | L2, B>;
 };
 /**
  * Type-safe interface for tap() with async detection
@@ -190,18 +154,18 @@ type EitherTapLeft = {
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherOrElse = {
-  <L1, R, L2$1, R2$1>(either: Either$1<L1, R>, fn: (left: L1) => Promise<Either$1<L2$1, R2$1>>): Promise<Either$1<L2$1, R | R2$1>>;
-  <L1, R, L2$1, R2$1>(either: Either$1<L1, R>, fn: (left: L1) => Either$1<L2$1, R2$1>): Either$1<L2$1, R | R2$1>;
-  <L1, L2$1, R2$1>(fn: (left: L1) => Promise<Either$1<L2$1, R2$1>>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2$1, R | R2$1>>;
-  <L1, L2$1, R2$1>(fn: (left: L1) => Either$1<L2$1, R2$1>): <R>(either: Either$1<L1, R>) => Either$1<L2$1, R | R2$1>;
+  <L1, R, L2, R2>(either: Either$1<L1, R>, fn: (left: L1) => Promise<Either$1<L2, R2>>): Promise<Either$1<L2, R | R2>>;
+  <L1, R, L2, R2>(either: Either$1<L1, R>, fn: (left: L1) => Either$1<L2, R2>): Either$1<L2, R | R2>;
+  <L1, L2, R2>(fn: (left: L1) => Promise<Either$1<L2, R2>>): <R>(either: Either$1<L1, R>) => Promise<Either$1<L2, R | R2>>;
+  <L1, L2, R2>(fn: (left: L1) => Either$1<L2, R2>): <R>(either: Either$1<L1, R>) => Either$1<L2, R | R2>;
 };
 /**
  * Type-safe interface for filter()
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherFilter = {
-  <L, R, L2$1>(either: Either$1<L, R>, predicate: (value: R) => boolean, onFail: (value: R) => L2$1): Either$1<L | L2$1, R>;
-  <R, L2$1>(predicate: (value: R) => boolean, onFail: (value: R) => L2$1): <L>(either: Either$1<L, R>) => Either$1<L | L2$1, R>;
+  <L, R, L2>(either: Either$1<L, R>, predicate: (value: R) => boolean, onFail: (value: R) => L2): Either$1<L | L2, R>;
+  <R, L2>(predicate: (value: R) => boolean, onFail: (value: R) => L2): <L>(either: Either$1<L, R>) => Either$1<L | L2, R>;
 };
 /**
  * Interface for unwrapOr function.
@@ -225,17 +189,31 @@ type EitherUnwrapOrElse = {
  * Supports both data-first and data-last (curried) calling styles via dual().
  */
 type EitherMatch = {
-  <L, R, U$1>(either: Either$1<L, R>, handlers: {
-    Left: (value: L) => U$1;
-    Right: (value: R) => U$1;
-  }): U$1;
-  <L, R, U$1>(handlers: {
-    Left: (value: L) => U$1;
-    Right: (value: R) => U$1;
-  }): (either: Either$1<L, R>) => U$1;
+  <L, R, U>(either: Either$1<L, R>, handlers: {
+    Left: (value: L) => U;
+    Right: (value: R) => U;
+  }): U;
+  <L, R, U>(handlers: {
+    Left: (value: L) => U;
+    Right: (value: R) => U;
+  }): (either: Either$1<L, R>) => U;
 };
-//#endregion
-//#region src/either/either.d.ts
+declare namespace either_d_exports {
+  export { Either, all, bimap, filter, flatMap, fromNullable, fromOption, fromPredicate, fromResult, isLeft, isRight, left, map, mapLeft, match, orElse, right, swap, tap, tapLeft, toOption, toResult, unwrapOr, unwrapOrElse };
+}
+/**
+ * Re-exported `Either` type.
+ *
+ * @example
+ * ```ts
+ * import type { Either } from "@nicolastoulemont/std"
+ *
+ * type Example = Either.Either<unknown, unknown>
+ * ```
+ *
+ * @category Re-exports
+ */
+type Either<L, R> = Either$1<L, R>;
 /**
  * Create a right Either value (success/preferred path).
  *
@@ -247,15 +225,13 @@ type EitherMatch = {
  *
  * @example
  * ```ts
- * const result = right(42)
- * // => { _tag: "Right", value: 42 }
+ * import { Either } from "@nicolastoulemont/std"
  *
- * // In Fx.gen() - never short-circuits
- * const fx = Fx.gen(function* () {
- *   const a = yield* Either.right(10)  // Returns 10
- *   return a * 2  // Executes, returns 20
- * })
+ * const value = Either.right(42)
+ * // => { _tag: "Right", value: 42 }
  * ```
+ *
+ * @category Constructors
  */
 declare const right: <R, L = never>(value: R) => Either$1<L, R>;
 /**
@@ -272,15 +248,13 @@ declare const right: <R, L = never>(value: R) => Either$1<L, R>;
  *
  * @example
  * ```ts
- * const cached = left({ source: "cache", data: cachedValue })
- * // => { _tag: "Left", value: { source: "cache", data: cachedValue } }
+ * import { Either } from "@nicolastoulemont/std"
  *
- * // In Fx.gen() - never short-circuits (unlike Result.err)
- * const fx = Fx.gen(function* () {
- *   const a = yield* Either.left("cached")  // Returns "cached"
- *   return a.toUpperCase()  // Executes, returns "CACHED"
- * })
+ * const value = Either.left("missing")
+ * // => { _tag: "Left", value: "missing" }
  * ```
+ *
+ * @category Constructors
  */
 declare const left: <L, R = never>(value: L) => Either$1<L, R>;
 /**
@@ -291,15 +265,30 @@ declare const left: <L, R = never>(value: L) => Either$1<L, R>;
  *
  * @example
  * ```ts
- * const either = right(42)
- * if (isRight(either)) {
- *   console.log(either.value) // Type: number
- * }
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const isRight = Either.isRight(Either.right(1))
+ * // => true
  * ```
+ *
+ * @category Guards
  */
 declare const isRight: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
   _tag: "Right";
 }>;
+/**
+ * isLeft utility.
+ *
+ * @example
+ * ```ts
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const isLeft = Either.isLeft(Either.left("missing"))
+ * // => true
+ * ```
+ *
+ * @category Guards
+ */
 declare const isLeft: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
   _tag: "Left";
 }>;
@@ -318,26 +307,17 @@ declare const isLeft: <L, R>(either: Either$1<L, R>) => either is Extract<Either
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * map(right(5), x => x * 2) // => right(10)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(5),
- *   map(x => x * 2)
- * ) // => right(10)
- *
- * pipe(
- *   left("error"),
- *   map(x => x * 2)
- * ) // => left("error")
- *
- * // Async usage
- * await pipe(
- *   right(userId),
- *   map(async id => await fetchUser(id))
- * ) // => Promise<Either<L, User>>
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.right(2)
+ * const dataFirst = Either.map(input, (n) => n + 1)
+ * // => { _tag: "Right", value: 3 }
+ *
+ * const dataLast = Either.map((n: number) => n + 1)(input)
+ * // => { _tag: "Right", value: 3 }
  * ```
+ *
+ * @category Mapping
  */
 declare const map: EitherMap;
 /**
@@ -355,20 +335,17 @@ declare const map: EitherMap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * mapLeft(left("error"), e => e.toUpperCase()) // => left("ERROR")
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   left("error"),
- *   mapLeft(e => e.toUpperCase())
- * ) // => left("ERROR")
- *
- * pipe(
- *   right(42),
- *   mapLeft(e => e.toUpperCase())
- * ) // => right(42)
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.left("missing")
+ * const dataFirst = Either.mapLeft(input, (msg) => msg.toUpperCase())
+ * // => { _tag: "Left", value: "MISSING" }
+ *
+ * const dataLast = Either.mapLeft((msg: string) => msg.toUpperCase())(input)
+ * // => { _tag: "Left", value: "MISSING" }
  * ```
+ *
+ * @category Mapping
  */
 declare const mapLeft: EitherMapLeft;
 /**
@@ -387,26 +364,17 @@ declare const mapLeft: EitherMapLeft;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * bimap(right(5), e => e.toUpperCase(), x => x * 2) // => right(10)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(5),
- *   bimap(
- *     e => e.toUpperCase(),
- *     x => x * 2
- *   )
- * ) // => right(10)
- *
- * pipe(
- *   left("error"),
- *   bimap(
- *     e => e.toUpperCase(),
- *     x => x * 2
- *   )
- * ) // => left("ERROR")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.left("missing")
+ * const dataFirst = Either.bimap(input, (left) => left.toUpperCase(), (right: number) => right + 1)
+ * // => { _tag: "Left", value: "MISSING" }
+ *
+ * const dataLast = Either.bimap((left: string) => left.toUpperCase(), (right: number) => right + 1)(input)
+ * // => { _tag: "Left", value: "MISSING" }
  * ```
+ *
+ * @category Mapping
  */
 declare const bimap: EitherBimap;
 /**
@@ -424,29 +392,17 @@ declare const bimap: EitherBimap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * flatMap(right(5), x => right(x * 2)) // => right(10)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(5),
- *   flatMap(x => right(x * 2)),
- *   flatMap(x => right(x + 1))
- * ) // => right(11)
- *
- * pipe(
- *   right(5),
- *   flatMap(x => left("error")),
- *   flatMap(x => right(x + 1)) // Not executed
- * ) // => left("error")
- *
- * // Async usage
- * await pipe(
- *   right(userId),
- *   flatMap(async id => right(await fetchUser(id))),
- *   flatMap(async user => right(await enrichProfile(user)))
- * ) // => Promise<Either<L, EnrichedUser>>
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.right(2)
+ * const dataFirst = Either.flatMap(input, (n) => Either.right(n + 1))
+ * // => { _tag: "Right", value: 3 }
+ *
+ * const dataLast = Either.flatMap((n: number) => Either.right(n + 1))(input)
+ * // => { _tag: "Right", value: 3 }
  * ```
+ *
+ * @category Sequencing
  */
 declare const flatMap: EitherFlatMap;
 /**
@@ -464,16 +420,22 @@ declare const flatMap: EitherFlatMap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * tap(right(42), x => console.log(x)) // Logs: 42, returns right(42)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(42),
- *   tap(x => console.log(x)), // Logs: 42
- *   map(x => x * 2)
- * ) // => right(84)
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * let seen = 0
+ * const input = Either.right(2)
+ * const dataFirst = Either.tap(input, (n) => {
+ *   seen = n
+ * })
+ * // => { _tag: "Right", value: 2 }
+ *
+ * const dataLast = Either.tap((n: number) => {
+ *   seen = n
+ * })(input)
+ * // => { _tag: "Right", value: 2 }
  * ```
+ *
+ * @category Sequencing
  */
 declare const tap: EitherTap;
 /**
@@ -491,16 +453,22 @@ declare const tap: EitherTap;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * tapLeft(left("error"), e => console.error(e)) // Logs: error, returns left("error")
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   left("error"),
- *   tapLeft(e => console.error(e)), // Logs: error
- *   mapLeft(e => e.toUpperCase())
- * ) // => left("ERROR")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * let seen = ""
+ * const input = Either.left("missing")
+ * const dataFirst = Either.tapLeft(input, (msg) => {
+ *   seen = msg
+ * })
+ * // => { _tag: "Left", value: "missing" }
+ *
+ * const dataLast = Either.tapLeft((msg: string) => {
+ *   seen = msg
+ * })(input)
+ * // => { _tag: "Left", value: "missing" }
  * ```
+ *
+ * @category Sequencing
  */
 declare const tapLeft: EitherTapLeft;
 /**
@@ -518,20 +486,17 @@ declare const tapLeft: EitherTapLeft;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * orElse(left("error"), () => right(42)) // => right(42)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   left("error"),
- *   orElse(() => right(42))
- * ) // => right(42)
- *
- * pipe(
- *   right(10),
- *   orElse(() => right(42))
- * ) // => right(10)
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.left("missing")
+ * const dataFirst = Either.orElse(input, () => Either.right(0))
+ * // => { _tag: "Right", value: 0 }
+ *
+ * const dataLast = Either.orElse(() => Either.right(0))(input)
+ * // => { _tag: "Right", value: 0 }
  * ```
+ *
+ * @category Error Handling
  */
 declare const orElse: EitherOrElse;
 /**
@@ -544,16 +509,14 @@ declare const orElse: EitherOrElse;
  *
  * @example
  * ```ts
- * pipe(
- *   left("error"),
- *   swap()
- * ) // => right("error")
- *
- * pipe(
- *   right(42),
- *   swap()
- * ) // => left(42)
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const swap = Either.swap<string, number>()
+ * const value = swap(Either.left("missing"))
+ * // => { _tag: "Right", value: "missing" }
  * ```
+ *
+ * @category Conversions
  */
 declare const swap: <L, R>() => (either: Either$1<L, R>) => Either$1<R, L>;
 /**
@@ -571,20 +534,17 @@ declare const swap: <L, R>() => (either: Either$1<L, R>) => Either$1<R, L>;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * filter(right(5), x => x > 3, x => `${x} is too small`) // => right(5)
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(5),
- *   filter(x => x > 3, x => `${x} is too small`)
- * ) // => right(5)
- *
- * pipe(
- *   right(2),
- *   filter(x => x > 3, x => `${x} is too small`)
- * ) // => left("2 is too small")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.right(3)
+ * const dataFirst = Either.filter(input, (n) => n > 0, (n) => `${n} must be positive`)
+ * // => { _tag: "Right", value: 3 }
+ *
+ * const dataLast = Either.filter((n: number) => n > 0, (n) => `${n} must be positive`)(input)
+ * // => { _tag: "Right", value: 3 }
  * ```
+ *
+ * @category Filtering
  */
 declare const filter: EitherFilter;
 /**
@@ -600,17 +560,13 @@ declare const filter: EitherFilter;
  *
  * @example
  * ```ts
- * // Array form - tuple types inferred automatically for up to 6 elements
- * all([right(1), right("hello")])
- * // => right([1, "hello"])
- *
- * all([right(1), left("error"), right(3)])
- * // => left("error")
+ * import { Either } from "@nicolastoulemont/std"
  *
- * // Object form
- * all({ a: right(1), b: right("hello") })
- * // => right({ a: 1, b: "hello" })
+ * const combined = Either.all([Either.right(1), Either.right(2)] as const)
+ * // => { _tag: "Right", value: [1, 2] }
  * ```
+ *
+ * @category Combining
  */
 declare const all: EitherAll;
 /**
@@ -627,21 +583,17 @@ declare const all: EitherAll;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * unwrapOr(right(42), 0) // => 42
- * unwrapOr(left("error"), 0) // => 0
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(42),
- *   unwrapOr(0)
- * ) // => 42
- *
- * pipe(
- *   left("error"),
- *   unwrapOr(0)
- * ) // => 0
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.left("missing") as Either.Either<string, number>
+ * const dataFirst = Either.unwrapOr(input, 0)
+ * // => 0
+ *
+ * const dataLast = Either.unwrapOr(0)(input)
+ * // => 0
  * ```
+ *
+ * @category Getters
  */
 declare const unwrapOr: EitherUnwrapOr;
 /**
@@ -656,21 +608,17 @@ declare const unwrapOr: EitherUnwrapOr;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * unwrapOrElse(right(42), () => 0) // => 42
- * unwrapOrElse(left("error"), e => e.length) // => 5
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(42),
- *   unwrapOrElse(() => 0)
- * ) // => 42
- *
- * pipe(
- *   left("error"),
- *   unwrapOrElse(e => e.length)
- * ) // => 5
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.left("missing") as Either.Either<string, number>
+ * const dataFirst = Either.unwrapOrElse(input, () => 0)
+ * // => 0
+ *
+ * const dataLast = Either.unwrapOrElse(() => 0)(input)
+ * // => 0
  * ```
+ *
+ * @category Getters
  */
 declare const unwrapOrElse: EitherUnwrapOrElse;
 /**
@@ -685,21 +633,23 @@ declare const unwrapOrElse: EitherUnwrapOrElse;
  *
  * @example
  * ```ts
- * // Data-first (direct call)
- * match(right(42), {
- *   Left: e => `Error: ${e}`,
- *   Right: x => `Success: ${x}`
- * }) // => "Success: 42"
- *
- * // Data-last (curried for pipe)
- * pipe(
- *   right(42),
- *   match({
- *     Left: e => `Error: ${e}`,
- *     Right: x => `Success: ${x}`
- *   })
- * ) // => "Success: 42"
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const input = Either.right(2) as Either.Either<string, number>
+ * const dataFirst = Either.match(input, {
+ *   Left: (left) => `error:${left}` ,
+ *   Right: (right) => `ok:${right}` ,
+ * })
+ * // => "ok:2"
+ *
+ * const dataLast = Either.match({
+ *   Left: (left: string) => `error:${left}` ,
+ *   Right: (right: number) => `ok:${right}` ,
+ * })(input)
+ * // => "ok:2"
  * ```
+ *
+ * @category Pattern Matching
  */
 declare const match: EitherMatch;
 /**
@@ -711,9 +661,15 @@ declare const match: EitherMatch;
  *
  * @example
  * ```ts
- * fromResult(Result.ok(42)) // => right(42)
- * fromResult(Result.err("error")) // => left("error")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * import { Result } from "@nicolastoulemont/std"
+ *
+ * const value = Either.fromResult(Result.ok(1))
+ * // => { _tag: "Right", value: 1 }
  * ```
+ *
+ * @category Conversions
  */
 declare const fromResult: <R, E>(result: Result<R, E>) => Either$1<E, R>;
 /**
@@ -727,16 +683,13 @@ declare const fromResult: <R, E>(result: Result<R, E>) => Either$1<E, R>;
  *
  * @example
  * ```ts
- * pipe(
- *   right(42),
- *   toResult
- * ) // => Result.ok(42)
- *
- * pipe(
- *   left("error"),
- *   toResult
- * ) // => Result.err("error")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const value = Either.toResult(Either.left("missing"))
+ * // => { _tag: "Err", error: "missing" }
  * ```
+ *
+ * @category Conversions
  */
 declare const toResult: <L, R>(either: Either$1<L, R>) => Result<R, L>;
 /**
@@ -749,9 +702,15 @@ declare const toResult: <L, R>(either: Either$1<L, R>) => Result<R, L>;
  *
  * @example
  * ```ts
- * fromOption(Option.some(42), () => "not found") // => right(42)
- * fromOption(Option.none(), () => "not found") // => left("not found")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Either.fromOption(Option.some(1), () => "missing")
+ * // => { _tag: "Right", value: 1 }
  * ```
+ *
+ * @category Conversions
  */
 declare const fromOption: <R, L>(option: Option<R>, onNone: () => L) => Either$1<L, R>;
 /**
@@ -765,16 +724,13 @@ declare const fromOption: <R, L>(option: Option<R>, onNone: () => L) => Either$1
  *
  * @example
  * ```ts
- * pipe(
- *   right(42),
- *   toOption
- * ) // => Option.some(42)
- *
- * pipe(
- *   left("error"),
- *   toOption
- * ) // => Option.none()
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const value = Either.toOption(Either.left("missing"))
+ * // => { _tag: "None" }
  * ```
+ *
+ * @category Conversions
  */
 declare const toOption: <L, R>(either: Either$1<L, R>) => Option<R>;
 /**
@@ -787,10 +743,13 @@ declare const toOption: <L, R>(either: Either$1<L, R>) => Option<R>;
  *
  * @example
  * ```ts
- * fromNullable(42, () => "not found") // => right(42)
- * fromNullable(null, () => "not found") // => left("not found")
- * fromNullable(undefined, () => "not found") // => left("not found")
+ * import { Either } from "@nicolastoulemont/std"
+ *
+ * const value = Either.fromNullable("Ada", () => "missing")
+ * // => { _tag: "Right", value: "Ada" }
  * ```
+ *
+ * @category Conversions
  */
 declare const fromNullable: <R, L>(value: R | null | undefined, onNull: () => L) => Either$1<L, R>;
 /**
@@ -804,79 +763,15 @@ declare const fromNullable: <R, L>(value: R | null | undefined, onNull: () => L)
  *
  * @example
  * ```ts
- * fromPredicate(5, x => x > 3, x => `${x} is too small`)
- * // => right(5)
+ * import { Either } from "@nicolastoulemont/std"
  *
- * fromPredicate(2, x => x > 3, x => `${x} is too small`)
- * // => left("2 is too small")
+ * const value = Either.fromPredicate(3, (n) => n > 0, (n) => `${n} must be positive`)
+ * // => { _tag: "Right", value: 3 }
  * ```
- */
-declare const fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
-/**
- * Either namespace containing all utility functions for working with Either types.
- *
- * Either represents a value that can be one of two types: Left<L> or Right<R>.
- * By convention, Right is the "success" or preferred path, while Left represents
- * an alternative outcome (not necessarily an error, unlike Result).
- *
- * Use Either when both outcomes are valid and meaningful, not just success/failure.
- * For error handling, prefer Result instead.
  *
- * @see {@link Result} for success/error semantics
- * @see {@link Option} for presence/absence semantics
- *
- * @example
- * ```ts
- * import { Either, pipe } from '@nicolastoulemont/std'
- * import type { Either as EitherType } from '@nicolastoulemont/std'
- *
- * // Either for branching logic (cache vs fresh data)
- * const fetchOrCache = (id: number): EitherType<CachedData, FreshData> =>
- *   cache.has(id) ? Either.left(cache.get(id)) : Either.right(fetch(id))
- *
- * const result = pipe(
- *   fetchOrCache(1),
- *   Either.map(data => data.value),
- *   Either.unwrapOr(defaultValue)
- * )
- *
- * // Async example
- * const processed = await pipe(
- *   Either.right(userId),
- *   Either.map(async id => await fetchUser(id)),
- *   Either.flatMap(async user => Either.right(await enrichUser(user)))
- * )
- * ```
+ * @category Constructors
  */
-declare const Either: {
-  readonly left: <L, R = never>(value: L) => Either$1<L, R>;
-  readonly right: <R, L = never>(value: R) => Either$1<L, R>;
-  readonly isLeft: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
-    _tag: "Left";
-  }>;
-  readonly isRight: <L, R>(either: Either$1<L, R>) => either is Extract<Either$1<L, R>, {
-    _tag: "Right";
-  }>;
-  readonly map: EitherMap;
-  readonly mapLeft: EitherMapLeft;
-  readonly bimap: EitherBimap;
-  readonly flatMap: EitherFlatMap;
-  readonly tap: EitherTap;
-  readonly tapLeft: EitherTapLeft;
-  readonly orElse: EitherOrElse;
-  readonly swap: <L, R>() => (either: Either$1<L, R>) => Either$1<R, L>;
-  readonly filter: EitherFilter;
-  readonly all: EitherAll;
-  readonly unwrapOr: EitherUnwrapOr;
-  readonly unwrapOrElse: EitherUnwrapOrElse;
-  readonly match: EitherMatch;
-  readonly fromResult: <R, E>(result: Result<R, E>) => Either$1<E, R>;
-  readonly toResult: <L, R>(either: Either$1<L, R>) => Result<R, L>;
-  readonly fromOption: <R, L>(option: Option<R>, onNone: () => L) => Either$1<L, R>;
-  readonly toOption: <L, R>(either: Either$1<L, R>) => Option<R>;
-  readonly fromNullable: <R, L>(value: R | null | undefined, onNull: () => L) => Either$1<L, R>;
-  readonly fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
-};
+declare const fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
 //#endregion
-export { FlatMapReturn as A, unwrapOr as C, BimapReturn as D, AllObjectReturn as E, OrElseReturn as F, Right as I, RightValue as L, LeftValue as M, MapLeftReturn as N, Either$1 as O, MapReturn as P, TapReturn as R, toResult as S, AllArrayReturn as T, right as _, flatMap as a, tapLeft as b, fromPredicate as c, isRight as d, left as f, orElse as g, match as h, filter as i, Left as j, FilterReturn as k, fromResult as l, mapLeft as m, all as n, fromNullable as o, map as p, bimap as r, fromOption as s, Either as t, isLeft as u, swap as v, unwrapOrElse as w, toOption as x, tap as y };
-//# sourceMappingURL=index-CklRfom5.d.mts.map
+export { either_d_exports as t };
+//# sourceMappingURL=index-B1-tBzc0.d.mts.map