FuncType - v0.60.3
    Preparing search index...

    Interface Functype<A, Tag>

    Interface for single-value containers like Option, Either, Try. Extends FunctypeBase with extraction methods and Pipe.

    interface Functype<A, Tag extends string = string> {
        _tag: Tag;
        "[toStringTag]": string;
        get isEmpty(): boolean;
        get size(): number;
        ap<B extends unknown>(ff: Applicative<(value: A) => B>): Applicative<B>;
        contains(value: unknown): boolean;
        count(p: (x: A) => boolean): number;
        exists(p: (a: A) => boolean): boolean;
        find(p: (a: A) => boolean): Option<A>;
        flatMap<B extends unknown>(f: (value: A) => Monad<B>): Monad<B>;
        flatMapAsync<B extends unknown>(
            f: (value: A) => PromiseLike<AsyncMonad<B>>,
        ): PromiseLike<AsyncMonad<B>>;
        foldLeft<B>(z: B): (op: (b: B, a: A) => B) => B;
        foldRight<B>(z: B): (op: (a: A, b: B) => B) => B;
        forEach(f: (a: A) => void): void;
        map<B extends unknown>(f: (value: A) => B): Functor<B>;
        match<R>(patterns: Record<Tags, (value: A) => R>): R;
        or<T2 extends unknown>(alternative: Extractable<T2>): Extractable<A | T2>;
        orElse<T2 extends unknown>(defaultValue: T2): A | T2;
        orNull(): A | null;
        orThrow(error?: Error): A;
        orUndefined(): A | undefined;
        pipe<U extends unknown>(f: (value: A) => U): U;
        reduce<B = A>(
            op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>,
        ): Widen<A, B>;
        reduceRight<B = A>(
            op: (b: Widen<A, B>, a: Widen<A, B>) => Widen<A, B>,
        ): Widen<A, B>;
        serialize(): SerializationMethods<A>;
        toValue(): { _tag: Tag; value: A };
    }

    Type Parameters

    • A

      The type of value contained

    • Tag extends string = string

      The type tag for pattern matching

    Hierarchy (View Summary)

    Index

    Properties

    _tag [toStringTag]

    Accessors

    isEmpty size

    Methods

    ap contains count exists find flatMap flatMapAsync foldLeft foldRight forEach map match or orElse orNull orThrow orUndefined pipe reduce reduceRight serialize toValue

    Properties

    Readonly_tag

    _tag: Tag
    "[toStringTag]": string

    Accessors

    Methods

    • Parameters

      • value: unknown

      Returns boolean

    • Counts elements that satisfy the predicate. For single-value containers: returns 0 or 1 For collections: returns the count of matching elements

      Parameters

      • p: (x: A) => boolean

      Returns number

    • Tests whether any element satisfies the predicate. For single-value containers: tests the single value For collections: returns true if any element matches

      Parameters

      • p: (a: A) => boolean

      Returns boolean

    • 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

      Parameters

      • p: (a: A) => boolean

      Returns Option<A>

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

      Type Parameters

      • B

      Parameters

      • z: B

        Zero/identity value

      Returns (op: (b: B, a: A) => 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: A, b: B) => B) => B

      A function that takes an operation to apply

    • Applies an effect function to each element. For single-value containers: applies to the value if present For collections: applies to each element

      Parameters

      • f: (a: A) => void

      Returns void

    • 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.

      Type Parameters

      • R

      Parameters

      • patterns: Record<Tags, (value: A) => R>

        An object containing handler functions for each variant

      Returns R

      The result of applying the matching handler function

    • 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

      • T2 extends unknown

      Parameters

      Returns Extractable<A | T2>

      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

      • T2 extends unknown

      Parameters

      • defaultValue: T2

        The value to return if extraction fails

      Returns A | T2

      The contained value or defaultValue

    • Returns the contained value or null

      Returns A | null

      The contained value or null

    • Extract the value or throw an error

      Parameters

      • Optionalerror: Error

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

      Returns A

      The contained value

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

    • Returns the contained value or undefined

      Returns A | undefined

      The contained value or undefined

    • Pipes the value through the provided function

      Type Parameters

      • U extends unknown

        The return type of the function

      Parameters

      • f: (value: A) => U

        The function to apply to the value

      Returns U

      The result of applying the function to the value

    • Returns { _tag: Tag; value: A }

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods