functype 0.8.80 → 0.8.82

package/dist/{Either-CfG7OVB-.d.ts → Either-CncND8cm.d.ts}

@@ -1,107 +1,4 @@
-import { T as Type, F as Functor, a as Typeable, V as Valuable, A as AsyncFunctor, E as ExtractTag } from './Valuable-BI2O7E9Q.js';
-
-/**
- * Foldable type class represents data structures that can be folded to a summary value.
- *
- * @typeParam A - The type of elements in the data structure
- */
-type Foldable<A> = {
-    /**
-     * Pattern matches over the structure, applying specific handlers for each variant
-     * @param onEmpty - Function to apply if the structure is empty or has no value
-     * @param onValue - Function to apply if the structure has a value
-     * @returns The result of applying the appropriate function
-     */
-    fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
-    /**
-     * Left-associative fold using the provided zero value and operation
-     * @param z - Zero/identity value
-     * @returns A function that takes an operation to apply
-     */
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    /**
-     * Right-associative fold using the provided zero value and operation
-     * @param z - Zero/identity value
-     * @returns A function that takes an operation to apply
-     */
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-};
-
-/**
- * Pattern matching interface for functional data types.
- *
- * @typeParam A - The type of elements in the data structure
- * @typeParam Tags - The type of tags used for pattern matching
- */
-type Matchable<A, Tags extends string = string> = {
-    /**
-     * Pattern matches against this data structure, applying handlers for each variant based on tag.
-     * Similar to fold but with stronger type safety for tag-based variants.
-     *
-     * The return type is inferred from the pattern handlers when not explicitly specified.
-     *
-     * @param patterns - An object containing handler functions for each variant
-     * @returns The result of applying the matching handler function
-     */
-    match<R>(patterns: Record<Tags, (value: A) => R>): R;
-};
-/**
- * Utility functions for working with Matchable data structures
- */
-declare const MatchableUtils: {
-    /**
-     * Helper function to create a default case for pattern matching
-     *
-     * @param handler - The default handler function to apply
-     * @returns A function that always applies the default handler
-     */
-    default: <A, R>(handler: (value: A) => R) => (value: A) => R;
-    /**
-     * Helper function to create a match pattern that guards based on a predicate
-     *
-     * @param predicate - The predicate function for guarding
-     * @param handler - The handler function to apply if the predicate passes
-     * @returns A function that applies the handler only if the predicate passes
-     */
-    when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
-};
-
-/**
- * Pipe interface for functional data structures
- * @typeParam T - The type of value to pipe
- */
-type Pipe<T extends Type> = {
-    /**
-     * Pipes the value through the provided function
-     * @param f - The function to apply to the value
-     * @returns The result of applying the function to the value
-     * @typeParam U - The return type of the function
-     */
-    pipe<U extends Type>(f: (value: T) => U): U;
-};
-
-/**
- * Methods for different serialization formats
- */
-type SerializationMethods<T> = {
-    toJSON(): string;
-    toYAML(): string;
-    toBinary(): string;
-};
-type Serializable<T> = {
-    serialize(): SerializationMethods<T>;
-};
-
-/**
- * Traversable typeclass for data structures that can be traversed through
- */
-type Traversable<A extends Type> = Functor<A> & {
-    get size(): number;
-    get isEmpty(): boolean;
-    contains(value: A): boolean;
-    reduce(f: (b: A, a: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-};
+import { T as Type, a as Typeable } from './Typeable-BBXrKPTY.js';
 
 /**
  * Creates a Some variant of Option containing a value.
@@ -134,9 +31,7 @@ declare const OptionConstructor: <T extends Type>(value: T | null | undefined) =
  * It's used to handle potentially null or undefined values in a type-safe way.
  * @typeParam T - The type of the value contained in the Option
  */
-type Option<T extends Type> = {
-    /** Tag identifying if this is a Some or None variant */
-    readonly _tag: "Some" | "None";
+interface Option<T extends Type> extends Functype<T, "Some" | "None"> {
     /** The contained value (undefined for None) */
     readonly value: T | undefined;
     /** Whether this Option contains no value */
@@ -182,6 +77,12 @@ type Option<T extends Type> = {
      * @returns A new Option containing the mapped value, or None if this Option is None
      */
     map<U extends Type>(f: (value: T) => U): Option<U>;
+    /**
+     * Applies a wrapped function to a wrapped value (Applicative pattern)
+     * @param ff - An Option containing a function from T to U
+     * @returns A new Option containing the result of applying the function
+     */
+    ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>;
     /**
      * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
      * @param predicate - The predicate function to test the value
@@ -272,7 +173,7 @@ type Option<T extends Type> = {
         Some: (value: T) => R;
         None: () => R;
     }): R;
-} & (Traversable<T> & Functor<T> & Typeable<"Some" | "None"> & Valuable<"Some" | "None", T> & AsyncFunctor<T> & Serializable<T> & Pipe<T> & Foldable<T> & Matchable<T, "Some" | "None">);
+}
 declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
     /**
      * Creates an Option from any value. Alias for Option function.
@@ -307,120 +208,22 @@ declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T
     fromBinary: <T>(binary: string) => Option<T>;
 };
 
-type IterableType<A extends Type> = {
-    count(p: (x: A) => boolean): number;
-    find(p: (a: A) => boolean): Option<A>;
-    forEach(f: (a: A) => void): void;
-    drop(n: number): IterableType<A>;
-    dropRight(n: number): IterableType<A>;
-    dropWhile(p: (a: A) => boolean): IterableType<A>;
-    exists(p: (a: A) => boolean): boolean;
-    filter(p: (a: A) => boolean): IterableType<A>;
-    filterNot(p: (a: A) => boolean): IterableType<A>;
-    flatten<B>(): IterableType<B>;
-    reduce(f: (b: A, a: A) => A): A;
-    reduceRight(f: (b: A, a: A) => A): A;
-    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
-    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
-    get head(): A | undefined;
-    get headOption(): Option<A>;
-    get isEmpty(): boolean;
-    map<B extends Type>(f: (a: A) => B): IterableType<B>;
-    flatMap<B extends Type>(f: (a: A) => IterableType<B>): IterableType<B>;
-    get size(): number;
-    toArray<B = A>(): readonly B[];
-} & Iterable<A> & Functor<A> & AsyncFunctor<A> & Traversable<A>;
-
-/**
- * Defines conversion methods for collection types
- * @interface
- * @module Collections
- * @category Core
- */
-type Converters<A> = {
-    toList(): List<A>;
-    toSet(): Set<A>;
-    toString(): string;
-};
-/**
- * Represents a collection with conversion capabilities
- * @interface
- * @module Collections
- * @category Core
- */
-type Collection<A> = Converters<A>;
-
-type Set<A> = {
-    add: (value: A) => Set<A>;
-    remove: (value: A) => Set<A>;
-    contains: (value: A) => boolean;
-    has: (value: A) => boolean;
-    map: <B>(f: (a: A) => B) => Set<B>;
-    flatMap: <B>(f: (a: A) => IterableType<B>) => Set<B>;
-    fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-} & IterableType<A> & Collection<A> & Typeable<"Set"> & Valuable<"Set", A[]> & Serializable<A[]> & Pipe<A[]> & Foldable<A>;
-declare const Set: (<A>(iterable?: Iterable<A> | IterableType<A>) => Set<A>) & {
-    /**
-     * Creates a Set from JSON string
-     * @param json - The JSON string
-     * @returns Set instance
-     */
-    fromJSON: <A>(json: string) => Set<A>;
-    /**
-     * Creates a Set from YAML string
-     * @param yaml - The YAML string
-     * @returns Set instance
-     */
-    fromYAML: <A>(yaml: string) => Set<A>;
-    /**
-     * Creates a Set from binary string
-     * @param binary - The binary string
-     * @returns Set instance
-     */
-    fromBinary: <A>(binary: string) => Set<A>;
-};
-
-type List<A> = {
+interface List<A> extends FunctypeCollection<A, "List"> {
     readonly length: number;
     readonly [Symbol.iterator]: () => Iterator<A>;
     map: <B>(f: (a: A) => B) => List<B>;
-    flatMap: <B>(f: (a: A) => IterableType<B>) => List<B>;
-    flatMapAsync: <B>(f: (a: A) => PromiseLike<IterableType<B>>) => PromiseLike<List<B>>;
-    forEach: (f: (a: A) => void) => void;
-    count: (p: (x: A) => boolean) => number;
-    exists: (p: (a: A) => boolean) => boolean;
+    ap: <B>(ff: List<(value: A) => B>) => List<B>;
+    flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>;
+    flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>;
     filter<S extends A>(predicate: (a: A) => a is S): List<S>;
     filter(predicate: (a: A) => unknown): List<A>;
     filterNot: (p: (a: A) => boolean) => List<A>;
     filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>;
-    find: <T extends A = A>(predicate: (a: A) => boolean, tag?: ExtractTag<T>) => Option<T>;
-    readonly head: A | undefined;
-    readonly headOption: Option<A>;
-    readonly isEmpty: boolean;
-    toArray: <B = A>() => B[];
-    reduce: (f: (prev: A, curr: A) => A) => A;
-    reduceRight: (f: (prev: A, curr: A) => A) => A;
-    foldLeft: <B>(z: B) => (op: (b: B, a: A) => B) => B;
-    foldRight: <B>(z: B) => (op: (a: A, b: B) => B) => B;
     remove: (value: A) => List<A>;
     removeAt: (index: number) => List<A>;
     add: (item: A) => List<A>;
     get: (index: number) => Option<A>;
     concat: (other: List<A>) => List<A>;
-    toList: () => List<A>;
-    toSet: () => Set<A>;
-    toString: () => string;
-    toValue: () => {
-        _tag: "List";
-        value: A[];
-    };
-    drop: (n: number) => List<A>;
-    dropRight: (n: number) => List<A>;
-    dropWhile: (p: (a: A) => boolean) => List<A>;
-    flatten: <B>() => List<B>;
     /**
      * Pattern matches over the List, applying a handler function based on whether it's empty
      * @param patterns - Object with handler functions for Empty and NonEmpty variants
@@ -430,7 +233,7 @@ type List<A> = {
         Empty: () => R;
         NonEmpty: (values: A[]) => R;
     }): R;
-} & IterableType<A> & AsyncFunctor<A> & Typeable<"List"> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
+}
 declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
     /**
      * Creates a List from JSON string
@@ -452,7 +255,361 @@ declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
     fromBinary: <A>(binary: string) => List<A>;
 };
 
-type TestEither<L extends Type, R extends Type> = Either<L, R> & Functor<R> & AsyncFunctor<R>;
+interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
+    add: (value: A) => Set<A>;
+    remove: (value: A) => Set<A>;
+    contains: (value: A) => boolean;
+    has: (value: A) => boolean;
+    map: <B>(f: (a: A) => B) => Set<B>;
+    flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
+    filter: (p: (a: A) => boolean) => Set<A>;
+    filterNot: (p: (a: A) => boolean) => Set<A>;
+    fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
+    toList: () => List<A>;
+    toSet: () => Set<A>;
+    toArray: <B = A>() => readonly B[];
+    toString: () => string;
+}
+declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
+    /**
+     * Creates a Set from JSON string
+     * @param json - The JSON string
+     * @returns Set instance
+     */
+    fromJSON: <A>(json: string) => Set<A>;
+    /**
+     * Creates a Set from YAML string
+     * @param yaml - The YAML string
+     * @returns Set instance
+     */
+    fromYAML: <A>(yaml: string) => Set<A>;
+    /**
+     * Creates a Set from binary string
+     * @param binary - The binary string
+     * @returns Set instance
+     */
+    fromBinary: <A>(binary: string) => Set<A>;
+};
+
+/**
+ * Represents a collection with conversion capabilities
+ * @interface
+ * @module Collections
+ * @category Core
+ */
+interface Collection<A> {
+    toList(): List<A>;
+    toSet(): Set<A>;
+    toString(): string;
+}
+
+/**
+ * Extractable type class for data structures that can extract their values
+ * with various fallback strategies.
+ *
+ * This interface is implemented by Option, Either, and other types that
+ * wrap values and need safe extraction methods.
+ */
+interface Extractable<T extends Type> {
+    /**
+     * Extracts the value unsafely
+     * @throws Error if the container is empty
+     * @returns The contained value
+     */
+    get(): T;
+    /**
+     * Returns the contained value or a default value
+     * @param defaultValue - The value to return if extraction fails
+     * @returns The contained value or defaultValue
+     */
+    getOrElse(defaultValue: T): T;
+    /**
+     * Returns the contained value or throws an error
+     * @param error - Optional error to throw (implementations may have defaults)
+     * @returns The contained value
+     * @throws The specified error if extraction fails
+     */
+    getOrThrow(error?: Error): T;
+    /**
+     * Returns this container if it has a value, otherwise returns the alternative
+     * @param alternative - The alternative container
+     * @returns This container or the alternative
+     */
+    orElse(alternative: Extractable<T>): Extractable<T>;
+    /**
+     * Returns the contained value or null
+     * @returns The contained value or null
+     */
+    orNull(): T | null;
+    /**
+     * Returns the contained value or undefined
+     * @returns The contained value or undefined
+     */
+    orUndefined(): T | undefined;
+}
+
+/**
+ * Foldable type class represents data structures that can be folded to a summary value.
+ *
+ * @typeParam A - The type of elements in the data structure
+ */
+interface Foldable<A> {
+    /**
+     * Pattern matches over the structure, applying specific handlers for each variant
+     * @param onEmpty - Function to apply if the structure is empty or has no value
+     * @param onValue - Function to apply if the structure has a value
+     * @returns The result of applying the appropriate function
+     */
+    fold<B>(onEmpty: () => B, onValue: (value: A) => B): B;
+    /**
+     * Left-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
+    /**
+     * Right-associative fold using the provided zero value and operation
+     * @param z - Zero/identity value
+     * @returns A function that takes an operation to apply
+     */
+    foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
+}
+
+/**
+ * Pattern matching interface for functional data types.
+ *
+ * @typeParam A - The type of elements in the data structure
+ * @typeParam Tags - The type of tags used for pattern matching
+ */
+interface Matchable<A, Tags extends string = string> {
+    /**
+     * Pattern matches against this data structure, applying handlers for each variant based on tag.
+     * Similar to fold but with stronger type safety for tag-based variants.
+     *
+     * The return type is inferred from the pattern handlers when not explicitly specified.
+     *
+     * @param patterns - An object containing handler functions for each variant
+     * @returns The result of applying the matching handler function
+     */
+    match<R>(patterns: Record<Tags, (value: A) => R>): R;
+}
+/**
+ * Utility functions for working with Matchable data structures
+ */
+declare const MatchableUtils: {
+    /**
+     * Helper function to create a default case for pattern matching
+     *
+     * @param handler - The default handler function to apply
+     * @returns A function that always applies the default handler
+     */
+    default: <A, R>(handler: (value: A) => R) => (value: A) => R;
+    /**
+     * Helper function to create a match pattern that guards based on a predicate
+     *
+     * @param predicate - The predicate function for guarding
+     * @param handler - The handler function to apply if the predicate passes
+     * @returns A function that applies the handler only if the predicate passes
+     */
+    when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
+};
+
+/**
+ * Pipe interface for functional data structures
+ * @typeParam T - The type of value to pipe
+ */
+interface Pipe<T extends Type> {
+    /**
+     * Pipes the value through the provided function
+     * @param f - The function to apply to the value
+     * @returns The result of applying the function to the value
+     * @typeParam U - The return type of the function
+     */
+    pipe<U extends Type>(f: (value: T) => U): U;
+}
+
+/**
+ * Methods for different serialization formats
+ */
+interface SerializationMethods<T> {
+    toJSON(): string;
+    toYAML(): string;
+    toBinary(): string;
+}
+interface Serializable<T> {
+    serialize(): SerializationMethods<T>;
+}
+
+/**
+ * Universal operations that work on any container (single-value or collection).
+ * These operations make sense for Option, Either, Try, List, Set, etc.
+ *
+ * @typeParam A - The type of value(s) in the container
+ */
+interface ContainerOps<A extends Type> {
+    /**
+     * Counts elements that satisfy the predicate.
+     * For single-value containers: returns 0 or 1
+     * For collections: returns the count of matching elements
+     */
+    count(p: (x: A) => boolean): number;
+    /**
+     * Finds the first element that satisfies the predicate.
+     * For single-value containers: returns Some(value) if predicate matches, None otherwise
+     * For collections: returns the first matching element wrapped in Option
+     */
+    find(p: (a: A) => boolean): Option<A>;
+    /**
+     * Tests whether any element satisfies the predicate.
+     * For single-value containers: tests the single value
+     * For collections: returns true if any element matches
+     */
+    exists(p: (a: A) => boolean): boolean;
+    /**
+     * Applies an effect function to each element.
+     * For single-value containers: applies to the value if present
+     * For collections: applies to each element
+     */
+    forEach(f: (a: A) => void): void;
+}
+/**
+ * Operations specific to collections (List, Set, etc.).
+ * These operations don't make sense for single-value containers.
+ *
+ * @typeParam A - The element type
+ * @typeParam Self - The collection type itself for proper return types
+ */
+interface CollectionOps<A extends Type, Self> {
+    /**
+     * Drops the first n elements from the collection.
+     */
+    drop(n: number): Self;
+    /**
+     * Drops the last n elements from the collection.
+     */
+    dropRight(n: number): Self;
+    /**
+     * Drops elements from the start while the predicate is true.
+     */
+    dropWhile(p: (a: A) => boolean): Self;
+    /**
+     * Flattens a collection of collections into a single collection.
+     */
+    flatten<B>(): Self;
+    /**
+     * Gets the first element of the collection.
+     */
+    get head(): A | undefined;
+    /**
+     * Gets the first element wrapped in Option.
+     */
+    get headOption(): Option<A>;
+    /**
+     * Converts the collection to an array.
+     */
+    toArray<B = A>(): readonly B[];
+}
+
+/**
+ * Functor type class - supports mapping over wrapped values
+ *
+ * Laws:
+ * - Identity: fa.map(x => x) ≡ fa
+ * - Composition: fa.map(f).map(g) ≡ fa.map(x => g(f(x)))
+ */
+interface Functor<A extends Type> {
+    map<B extends Type>(f: (value: A) => B): Functor<B>;
+}
+/**
+ * Applicative functor - supports applying wrapped functions to wrapped values
+ *
+ * Laws:
+ * - Identity: pure(x => x).ap(v) ≡ v
+ * - Composition: pure(compose).ap(u).ap(v).ap(w) ≡ u.ap(v.ap(w))
+ * - Homomorphism: pure(f).ap(pure(x)) ≡ pure(f(x))
+ * - Interchange: u.ap(pure(y)) ≡ pure(f => f(y)).ap(u)
+ */
+interface Applicative<A extends Type> extends Functor<A> {
+    ap<B extends Type>(ff: Applicative<(value: A) => B>): Applicative<B>;
+}
+/**
+ * Monad type class - supports flat mapping (chaining) operations
+ *
+ * Laws:
+ * - Left identity: pure(a).flatMap(f) ≡ f(a)
+ * - Right identity: m.flatMap(pure) ≡ m
+ * - Associativity: m.flatMap(f).flatMap(g) ≡ m.flatMap(x => f(x).flatMap(g))
+ */
+interface Monad<A extends Type> extends Applicative<A> {
+    flatMap<B extends Type>(f: (value: A) => Monad<B>): Monad<B>;
+}
+/**
+ * Async monad - supports asynchronous monadic operations
+ * Extends Monad so it has map, ap, and flatMap in addition to flatMapAsync
+ */
+interface AsyncMonad<A extends Type> extends Monad<A> {
+    flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<AsyncMonad<B>>): PromiseLike<AsyncMonad<B>>;
+}
+
+/**
+ * Traversable typeclass for data structures that can be traversed through
+ */
+interface Traversable<A extends Type> extends AsyncMonad<A> {
+    get size(): number;
+    get isEmpty(): boolean;
+    contains(value: A): boolean;
+    reduce(f: (b: A, a: A) => A): A;
+    reduceRight(f: (b: A, a: A) => A): A;
+}
+
+/**
+ * Base interface for all functype data structures.
+ * This provides a standard contract with core functional programming traits.
+ *
+ * @typeParam A - The type of value contained in the functor
+ * @typeParam Tag - The type tag for pattern matching (e.g., "Some" | "None" for Option)
+ *
+ * @example
+ * ```typescript
+ * // Implementing FunctypeBase for a custom data structure
+ * class MyContainer<T> implements FunctypeBase<T, "Empty" | "Full"> {
+ *   // Implementation of all required methods...
+ * }
+ * ```
+ */
+interface FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
+    readonly _tag: Tag;
+}
+/**
+ * Interface for single-value containers like Option, Either, Try.
+ * Extends FunctypeBase with extraction methods and Pipe.
+ *
+ * @typeParam A - The type of value contained
+ * @typeParam Tag - The type tag for pattern matching
+ */
+interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>, Matchable<A, Tag> {
+    toValue(): {
+        _tag: Tag;
+        value: A;
+    };
+}
+/**
+ * A version of Functype for collection types that need iteration support.
+ * Extends FunctypeBase with Iterable protocol but without Extractable.
+ *
+ * @typeParam A - The element type of the collection
+ * @typeParam Tag - The type tag for pattern matching
+ */
+interface FunctypeCollection<A, Tag extends string = string> extends Omit<FunctypeBase<A, Tag>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
+    toValue(): {
+        _tag: Tag;
+        value: A[];
+    };
+    flatMap<B extends Type>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>;
+    flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag>>;
+}
+
+type TestEither<L extends Type, R extends Type> = Either<L, R> & AsyncMonad<R>;
 declare const Right: <L extends Type, R extends Type>(value: R) => Either<L, R>;
 declare const Left: <L extends Type, R extends Type>(value: L) => Either<L, R>;
 declare const isRight: <L extends Type, R extends Type>(either: Either<L, R>) => either is Either<L, R> & {
@@ -470,14 +627,19 @@ declare const tryCatchAsync: <L extends Type, R extends Type>(f: () => Promise<R
  * @module Either
  * @category Core
  */
-type Either<L extends Type, R extends Type> = {
+interface Either<L extends Type, R extends Type> extends FunctypeBase<R, "Left" | "Right">, PromiseLike<R> {
     readonly _tag: "Left" | "Right";
     value: L | R;
     isLeft: () => boolean;
     isRight: () => boolean;
+    get: () => R;
     getOrElse: (defaultValue: R) => R;
-    getOrThrow: () => R;
+    getOrThrow: (error?: Error) => R;
+    orElse(alternative: Either<L, R>): Either<L, R>;
+    orNull: () => R | null;
+    orUndefined: () => R | undefined;
     map: <U extends Type>(f: (value: R) => U) => Either<L, U>;
+    ap: <U extends Type>(ff: Either<L, (value: R) => U>) => Either<L, U>;
     merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>;
     mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>;
     flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>;
@@ -504,7 +666,7 @@ type Either<L extends Type, R extends Type> = {
     pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U;
     /**
      * Pipes the Either value through the provided function
-     * @param f - The function to apply to the value
+     * @param f - The function to apply to the value (Left or Right)
      * @returns The result of applying the function to the value
      */
     pipe<U extends Type>(f: (value: L | R) => U): U;
@@ -517,7 +679,21 @@ type Either<L extends Type, R extends Type> = {
         Left: (value: L) => T;
         Right: (value: R) => T;
     }): T;
-} & Typeable<"Left" | "Right"> & Valuable<"Left" | "Right", L | R> & PromiseLike<R> & AsyncFunctor<R> & Serializable<R> & Pipe<L | R> & Foldable<R> & Matchable<L | R, "Left" | "Right">;
+    /**
+     * Returns the value and tag for inspection
+     */
+    toValue(): {
+        _tag: "Left" | "Right";
+        value: L | R;
+    };
+    /**
+     * Custom JSON serialization that excludes getter properties
+     */
+    toJSON(): {
+        _tag: "Left" | "Right";
+        value: L | R;
+    };
+}
 declare const Either: {
     sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]) => Either<L, R[]>;
     traverse: <L extends Type, R extends Type, U extends Type>(arr: R[], f: (value: R) => Either<L, U>) => Either<L, U[]>;
@@ -530,4 +706,4 @@ declare const Either: {
     fromBinary: <L extends Type, R extends Type>(binary: string) => Either<L, R>;
 };
 
-export { type Converters as C, Either as E, type Foldable as F, type IterableType as I, List as L, type Matchable as M, None as N, Option as O, type Pipe as P, Right as R, type Serializable as S, type Traversable as T, type Collection as a, type TestEither as b, Left as c, isLeft as d, TypeCheckRight as e, TypeCheckLeft as f, tryCatchAsync as g, MatchableUtils as h, isRight as i, Some as j, OptionConstructor as k, type SerializationMethods as l, Set as m, tryCatch as t };
+export { type AsyncMonad as A, type Collection as C, Either as E, type Foldable as F, List as L, type Matchable as M, None as N, Option as O, type Pipe as P, Right as R, type Serializable as S, type Traversable as T, type FunctypeBase as a, type Extractable as b, type TestEither as c, Left as d, isLeft as e, TypeCheckRight as f, TypeCheckLeft as g, tryCatchAsync as h, isRight as i, type Functype as j, type FunctypeCollection as k, MatchableUtils as l, Some as m, OptionConstructor as n, type SerializationMethods as o, Set as p, type CollectionOps as q, type ContainerOps as r, type Applicative as s, tryCatch as t, type Functor as u, type Monad as v };