FuncType - v1.4.1
    Preparing search index...

    Interface LeftOf<L, R>

    Left variant of Either. Discriminated by _tag: "Left" with value: L.

    interface LeftOf<out L extends Type, out R extends Type> {
        _tag: "Left";
        "[iterator]": () => Iterator<R>;
        "[toStringTag]": string;
        ap: <L2 extends unknown, U extends unknown>(
            ff: Either<L2, (value: R) => U>,
        ) => Either<L | L2, U>;
        bimap: <L2 extends unknown, R2 extends unknown>(
            fl: (value: L) => L2,
            fr: (value: R) => R2,
        ) => Either<L2, R2>;
        expect: (handler: (value: L) => never) => R;
        flatMap: <L2 extends unknown, U extends unknown>(
            f: (value: R) => Either<L2, U>,
        ) => Either<L | L2, U>;
        flatMapAsync: <L2 extends unknown, U extends unknown>(
            f: (value: R) => Promise<Either<L2, U>>,
        ) => Promise<Either<L | L2, U>>;
        fold: <T extends unknown>(
            onLeft: (value: L) => T,
            onRight: (value: R) => T,
        ) => T;
        foldAsync: <T extends unknown>(
            onLeft: (value: L) => T | Promise<T>,
            onRight: (value: R) => T | Promise<T>,
        ) => Promise<T>;
        map: <U extends unknown>(f: (value: R) => U) => Either<L, U>;
        mapAsync: <U extends unknown>(
            f: (value: R) => Promise<U>,
        ) => Promise<Either<L, U>>;
        mapLeft: <L2 extends unknown>(f: (value: L) => L2) => Either<L2, R>;
        merge: <L1 extends unknown, R1 extends unknown>(
            other: Either<L1, R1>,
        ) => Either<L | L1, [R, R1]>;
        orNull: () => R | null;
        orThrow: (error?: Error) => R;
        orUndefined: () => R | undefined;
        swap: () => Either<R, L>;
        tap: (f: (value: R) => void) => Either<L, R>;
        tapLeft: (f: (value: L) => void) => Either<L, R>;
        toOption: () => Option<R>;
        toString: () => string;
        traverse: <L2 extends unknown, U extends unknown>(
            f: (value: R) => Either<L2, U>,
        ) => Either<L | L2, U[]>;
        value: L;
        yield: () => Generator<R, void, unknown>;
        contains(value: R): boolean;
        doUnwrap(): DoResult<R>;
        exists(p: (a: R) => boolean): boolean;
        foldLeft<B>(z: B): (op: (b: B, a: R) => B) => B;
        foldRight<B>(z: B): (op: (a: R, b: B) => B) => B;
        forEach(f: (a: R) => void): void;
        isLeft(): this is LeftOf<L, R>;
        isRight(): this is RightOf<L, R>;
        match<T>(patterns: { Left: (value: L) => T; Right: (value: R) => T }): T;
        or<L2 extends unknown, R2 extends unknown>(
            alternative: Either<L2, R2>,
        ): Either<L | L2, R | R2>;
        orElse<R2 extends unknown>(defaultValue: R2): R | R2;
        pipe<U extends unknown>(f: (value: L | R) => U): U;
        pipeEither<U extends unknown>(
            onLeft: (value: L) => U,
            onRight: (value: R) => U,
        ): U;
        serialize(): SerializationMethods<R>;
        toEither<E extends unknown>(leftValue: E): Either<E, R>;
        toJSON(): { _tag: "Left" | "Right"; "@functype": "Either"; value: L | R };
        toList(): List<R>;
        toPromise(): Promise<R>;
        toTry(): Try<R>;
        toValue(): { _tag: "Left" | "Right"; value: L | R };
    }

    Type Parameters

    Hierarchy (View Summary)

    Index

    Properties

    _tag [iterator] [toStringTag] ap bimap expect flatMap flatMapAsync fold foldAsync map mapAsync mapLeft merge orNull orThrow orUndefined swap tap tapLeft toOption toString traverse value yield

    Methods

    contains doUnwrap exists foldLeft foldRight forEach isLeft isRight match or orElse pipe pipeEither serialize toEither toJSON toList toPromise toTry toValue

    Properties

    Readonly_tag

    _tag: "Left"
    "[iterator]": () => Iterator<R>
    "[toStringTag]": string
    ap: <L2 extends unknown, U extends unknown>(
        ff: Either<L2, (value: R) => U>,
    ) => Either<L | L2, U>
    bimap: <L2 extends unknown, R2 extends unknown>(
        fl: (value: L) => L2,
        fr: (value: R) => R2,
    ) => Either<L2, R2>
    expect: (handler: (value: L) => never) => R

    Returns the right value, or calls the never-returning handler with the Left's value. Use this when you have a helper like (msg) => fail(msg, 2) that terminates the program — the result type is unconditionally R, so you avoid the TypeScript narrowing trap where if (e.isLeft()) fail(...) fails to narrow e.value when fail is an arrow function typed as (...): never.

    flatMap: <L2 extends unknown, U extends unknown>(
        f: (value: R) => Either<L2, U>,
    ) => Either<L | L2, U>
    flatMapAsync: <L2 extends unknown, U extends unknown>(
        f: (value: R) => Promise<Either<L2, U>>,
    ) => Promise<Either<L | L2, U>>
    fold: <T extends unknown>(
        onLeft: (value: L) => T,
        onRight: (value: R) => T,
    ) => T
    foldAsync: <T extends unknown>(
        onLeft: (value: L) => T | Promise<T>,
        onRight: (value: R) => T | Promise<T>,
    ) => Promise<T>

    Async variant of fold. Accepts sync or async handlers on either branch and always returns a Promise, keeping chains fluent when at least one branch is async.

    map: <U extends unknown>(f: (value: R) => U) => Either<L, U>
    mapAsync: <U extends unknown>(
        f: (value: R) => Promise<U>,
    ) => Promise<Either<L, U>>
    mapLeft: <L2 extends unknown>(f: (value: L) => L2) => Either<L2, R>
    merge: <L1 extends unknown, R1 extends unknown>(
        other: Either<L1, R1>,
    ) => Either<L | L1, [R, R1]>
    orNull: () => R | null

    Returns the contained value or null

    Type Declaration

      • (): R | null

      • Returns R | null

        The contained value or null

    orThrow: (error?: Error) => R

    Extract the value or throw an error

    Type Declaration

      • (error?: Error): R

      • Parameters

        • Optionalerror: Error

          Optional custom error to throw. If not provided, uses type-appropriate default error

        Returns R

        The contained value

    The specified error, container's error, or a sensible default

    orUndefined: () => R | undefined

    Returns the contained value or undefined

    Type Declaration

      • (): R | undefined

      • Returns R | undefined

        The contained value or undefined

    swap: () => Either<R, L>
    tap: (f: (value: R) => void) => Either<L, R>
    tapLeft: (f: (value: L) => void) => Either<L, R>
    toOption: () => Option<R>

    Converts this monad to an Option.

    Conversion rules:

    • Option: returns self
    • Either: Right → Some, Left → None
    • List: non-empty → Some(head), empty → None
    • Try: Success → Some, Failure → None

    Type Declaration

      • (): Option<R>

      • Returns Option<R>

        An Option containing the value if present, None otherwise

    toString: () => string

    Returns a string representation of an object.

    traverse: <L2 extends unknown, U extends unknown>(
        f: (value: R) => Either<L2, U>,
    ) => Either<L | L2, U[]>
    value: L
    yield: () => Generator<R, void, unknown>

    Methods

    • Parameters

      • p: (a: R) => boolean

      Returns boolean

    • Left-associative fold using the provided zero value and operation

      Type Parameters

      • B

      Parameters

      • z: B

        Zero/identity value

      Returns (op: (b: B, a: R) => B) => B

      A function that takes an operation to apply

    • Right-associative fold using the provided zero value and operation

      Type Parameters

      • B

      Parameters

      • z: B

        Zero/identity value

      Returns (op: (a: R, b: B) => B) => B

      A function that takes an operation to apply

    • Parameters

      • f: (a: R) => void

      Returns void

    • Pattern matches over the Either, applying a handler function based on the variant

      Type Parameters

      • T

      Parameters

      • patterns: { Left: (value: L) => T; Right: (value: R) => T }

      Returns T

    • Returns this container if it has a value, otherwise returns the alternative container. The alternative may carry a different type; the result widens to Extractable<T | T2>.

      Type Parameters

      • L2 extends unknown
      • R2 extends unknown

      Parameters

      • alternative: Either<L2, R2>

        The alternative container

      Returns Either<L | L2, R | R2>

      This container or the alternative

    • Returns the contained value or a default value. The default may be of a different type; the result widens to T | T2.

      Type Parameters

      • R2 extends unknown

      Parameters

      • defaultValue: R2

        The value to return if extraction fails

      Returns R | R2

      The contained value or defaultValue

    • Pipes the Either value through the provided function

      Type Parameters

      • U extends unknown

      Parameters

      • f: (value: L | R) => U

      Returns U

    • Pipes the value through the provided function based on whether this is a Left or Right

      Type Parameters

      • U extends unknown

      Parameters

      • onLeft: (value: L) => U
      • onRight: (value: R) => U

      Returns U

    • Converts this monad to an Either.

      Conversion rules:

      • Option: Some → Right, None → Left(leftValue)
      • Either: returns self
      • List: non-empty → Right(head), empty → Left(leftValue)
      • Try: Success → Right, Failure → Left(leftValue). Try also accepts a builder (err: Error) => E to thread the underlying Error's context into the Left.

      Type Parameters

      • E extends unknown

      Parameters

      • leftValue: E

        The value to use for the Left case when the source is empty/none/failure

      Returns Either<E, R>

      An Either with the value as Right or the provided leftValue as Left

    • Custom JSON serialization that excludes getter properties. Emits the canonical functype envelope with @functype: "Either" so native JSON.stringify recursion (e.g. inside a plain object body) produces a marker-bearing envelope that survives a round-trip through Serialization.deserialize.

      Returns { _tag: "Left" | "Right"; "@functype": "Either"; value: L | R }

    • Converts this monad to a List.

      Conversion rules:

      • Option: Some → List([value]), None → List([])
      • Either: Right → List([value]), Left → List([])
      • List: returns self
      • Try: Success → List([value]), Failure → List([])

      Returns List<R>

      A List containing the value(s) if present, empty List otherwise

    • Converts this container to a Promise

      The behavior depends on the implementing container:

      • Success/Right/Some containers resolve with their value
      • Failure/Left/None containers reject with their error/default error

      Returns Promise<R>

      A Promise that resolves or rejects based on the container's state

    • Converts this monad to a Try.

      Conversion rules:

      • Option: Some → Success, None → Failure(Error("None"))
      • Either: Right → Success, Left → Failure(Error(leftValue))
      • List: non-empty → Success(head), empty → Failure(Error("Empty list"))
      • Try: returns self

      Returns Try<R>

      A Try containing Success with the value or Failure with an appropriate error

    • Returns the value and tag for inspection

      Returns { _tag: "Left" | "Right"; value: L | R }

    Settings

    Member Visibility

    On This Page

    Properties
    Methods