FuncType - v0.60.3
    Preparing search index...

    Interface FunctypeCollection<A, Tag>

    A version of Functype for collection types that need iteration support. Extends FunctypeBase with Iterable protocol but without Extractable.

    interface FunctypeCollection<A, Tag extends string = string> {
        _tag: Tag;
        "[toStringTag]": string;
        isEmpty: boolean;
        size: number;
        get head(): A | undefined;
        get headOption(): Option<A>;
        get init(): Self;
        get last(): A | undefined;
        get lastOption(): Option<A>;
        get tail(): Self;
        ap<B extends unknown>(ff: Applicative<(value: A) => B>): Applicative<B>;
        contains(value: unknown): boolean;
        count(p: (x: A) => boolean): number;
        drop(n: number): FunctypeCollection;
        dropRight(n: number): FunctypeCollection;
        dropWhile(p: (a: A) => boolean): FunctypeCollection;
        exists(p: (a: A) => boolean): boolean;
        find(p: (a: A) => boolean): Option<A>;
        flatMap<B extends unknown>(
            f: (value: A) => Iterable<B>,
        ): FunctypeCollection<B, Tag>;
        flatMapAsync<B extends unknown>(
            f: (value: A) => PromiseLike<Iterable<B, any, any>>,
        ): PromiseLike<FunctypeCollection<B, Tag>>;
        flatten<B>(): FunctypeCollection;
        fold<B>(initial: B, fn: (acc: B, a: A) => B): 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>;
        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>;
        take(n: number): FunctypeCollection;
        takeRight(n: number): FunctypeCollection;
        takeWhile(p: (a: A) => boolean): FunctypeCollection;
        toArray<B = A>(): B[];
        toList(): List<A>;
        toSet(): Set<A>;
        toString(): string;
        toValue(): { _tag: Tag; value: A[] };
    }

    Type Parameters

    • A

      The element type of the collection

    • Tag extends string = string

      The type tag for pattern matching

    Hierarchy (View Summary)

    Index

    Properties

    _tag [toStringTag] isEmpty size

    Accessors

    head headOption init last lastOption tail

    Methods

    ap contains count drop dropRight dropWhile exists find flatMap flatMapAsync flatten fold foldLeft foldRight forEach map pipe reduce reduceRight serialize take takeRight takeWhile toArray toList toSet toString toValue

    Properties

    Readonly_tag

    _tag: Tag
    "[toStringTag]": string
    isEmpty: boolean
    size: number

    Accessors

    • get head(): A | undefined

      Gets the first element of the collection.

      Returns A | undefined

    • get headOption(): Option<A>

      Gets the first element wrapped in Option.

      Returns Option<A>

    • get init(): Self

      Gets all elements except the last.

      Returns Self

    • get last(): A | undefined

      Gets the last element of the collection.

      Returns A | undefined

    • get lastOption(): Option<A>

      Gets the last element wrapped in Option.

      Returns Option<A>

    • get tail(): Self

      Gets all elements except the first.

      Returns Self

    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>

    • Type Parameters

      • B extends unknown

      Parameters

      • f: (value: A) => PromiseLike<Iterable<B, any, any>>

      Returns PromiseLike<FunctypeCollection<B, Tag>>

    • Left-associative fold over all elements using an initial value and combining function. Unlike foldLeft (which is curried), this provides a convenient uncurried signature.

      Type Parameters

      • B

      Parameters

      • initial: B

        The initial accumulator value

      • fn: (acc: B, a: A) => B

        A function that combines the accumulator with each element

      Returns B

      The final accumulated value

      List([1, 2, 3]).fold(0, (acc, x) => acc + x) // 6

    • 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

    • Type Parameters

      • B extends unknown

      Parameters

      • f: (value: A) => B

      Returns Functor<B>

    • 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

    • Converts the collection to an array.

      Type Parameters

      • B = A

      Returns B[]

    • Returns { _tag: Tag; value: A[] }

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods