FuncType - v0.49.0
    Preparing search index...

    Interface List<A>

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

    interface List<A> {
        _tag: "List";
        "[iterator]": () => Iterator<A>;
        "[toStringTag]": string;
        add: (item: A) => List<A>;
        ap: <B>(ff: List<(value: A) => B>) => List<B>;
        concat: (other: List<A>) => List<A>;
        distinct: () => List<A>;
        filterNot: (p: (a: A) => boolean) => List<A>;
        flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>;
        flatMapAsync: <B>(
            f: (a: A) => PromiseLike<Iterable<B, any, any>>,
        ) => PromiseLike<List<B>>;
        get: (index: number) => Option<A>;
        groupBy: <K>(f: (a: A) => K) => Map<K, List<A>>;
        indexOf: (value: A) => number;
        isEmpty: boolean;
        length: number;
        map: <B>(f: (a: A) => B) => List<B>;
        partition: (p: (a: A) => boolean) => [List<A>, List<A>];
        prepend: (item: A) => List<A>;
        remove: (value: A) => List<A>;
        removeAt: (index: number) => List<A>;
        reverse: () => List<A>;
        size: number;
        slice: (start: number, end: number) => List<A>;
        sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>;
        sorted: (compareFn?: (a: A, b: A) => number) => List<A>;
        span: (p: (a: A) => boolean) => [List<A>, List<A>];
        take: (n: number) => List<A>;
        takeRight: (n: number) => List<A>;
        takeWhile: (p: (a: A) => boolean) => List<A>;
        zip: <B>(other: List<B>) => List<[A, B]>;
        zipWithIndex: () => List<[A, number]>;
        get head(): A | undefined;
        get headOption(): Option<A>;
        get init(): List<A>;
        get last(): A | undefined;
        get lastOption(): Option<A>;
        get tail(): List<A>;
        contains(value: A): boolean;
        count(p: (x: A) => boolean): number;
        doUnwrap(): DoResult<A>;
        drop(n: number): FunctypeCollection;
        dropRight(n: number): FunctypeCollection;
        dropWhile(p: (a: A) => boolean): FunctypeCollection;
        exists(p: (a: A) => boolean): boolean;
        filter<S>(predicate: (a: A) => a is S): List<S>;
        filter(predicate: (a: A) => unknown): List<A>;
        find(p: (a: A) => boolean): Option<A>;
        flatten<B>(): FunctypeCollection;
        fold<B>(onEmpty: () => B, onValue: (value: 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;
        match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R;
        pipe<U extends unknown>(f: (value: A[]) => U): U;
        reduce(f: (b: A, a: A) => A): A;
        reduceRight(f: (b: A, a: A) => A): A;
        serialize(): SerializationMethods<A>;
        toArray<B = A>(): B[];
        toEither<E extends unknown>(leftValue: E): Either<E, A>;
        toList(): List<A>;
        toOption(): Option<A>;
        toSet(): Set<A>;
        toString(): string;
        toTry(): Try<A>;
        toValue(): { _tag: "List"; value: A[] };
    }

    Type Parameters

    • A

      The element type of the collection

    Hierarchy (View Summary)

    Index

    Properties

    _tag [iterator] [toStringTag] add ap concat distinct filterNot flatMap flatMapAsync get groupBy indexOf isEmpty length map partition prepend remove removeAt reverse size slice sortBy sorted span take takeRight takeWhile zip zipWithIndex

    Accessors

    head headOption init last lastOption tail

    Methods

    contains count doUnwrap drop dropRight dropWhile exists filter find flatten fold foldLeft foldRight forEach match pipe reduce reduceRight serialize toArray toEither toList toOption toSet toString toTry toValue

    Properties

    Readonly_tag

    _tag: "List"
    "[iterator]": () => Iterator<A>
    "[toStringTag]": string
    add: (item: A) => List<A>
    ap: <B>(ff: List<(value: A) => B>) => List<B>
    concat: (other: List<A>) => List<A>
    distinct: () => List<A>
    filterNot: (p: (a: A) => boolean) => List<A>
    flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>
    flatMapAsync: <B>(
        f: (a: A) => PromiseLike<Iterable<B, any, any>>,
    ) => PromiseLike<List<B>>
    get: (index: number) => Option<A>
    groupBy: <K>(f: (a: A) => K) => Map<K, List<A>>
    indexOf: (value: A) => number
    isEmpty: boolean
    length: number
    map: <B>(f: (a: A) => B) => List<B>
    partition: (p: (a: A) => boolean) => [List<A>, List<A>]
    prepend: (item: A) => List<A>
    remove: (value: A) => List<A>
    removeAt: (index: number) => List<A>
    reverse: () => List<A>
    size: number
    slice: (start: number, end: number) => List<A>
    sortBy: <B>(f: (a: A) => B, compareFn?: (a: B, b: B) => number) => List<A>
    sorted: (compareFn?: (a: A, b: A) => number) => List<A>
    span: (p: (a: A) => boolean) => [List<A>, List<A>]
    take: (n: number) => List<A>

    Takes the first n elements from the collection.

    takeRight: (n: number) => List<A>

    Takes the last n elements from the collection.

    takeWhile: (p: (a: A) => boolean) => List<A>

    Takes elements from the start while the predicate is true.

    zip: <B>(other: List<B>) => List<[A, B]>
    zipWithIndex: () => List<[A, 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(): List<A>

      Gets all elements except the last.

      Returns List<A>

    • 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(): List<A>

      Gets all elements except the first.

      Returns List<A>

    Methods

    • 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

    • Type Parameters

      • S

      Parameters

      • predicate: (a: A) => a is S

      Returns List<S>

    • Parameters

      • predicate: (a: A) => unknown

      Returns List<A>

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

    • Pattern matches over the structure, applying specific handlers for each variant

      Type Parameters

      • B

      Parameters

      • onEmpty: () => B

        Function to apply if the structure is empty or has no value

      • onValue: (value: A) => B

        Function to apply if the structure has a value

      Returns B

      The result of applying the appropriate function

    • 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 over the List, applying a handler function based on whether it's empty

      Type Parameters

      • R

      Parameters

      • patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }

        Object with handler functions for Empty and NonEmpty variants

      Returns R

      The result of applying the matching handler function

    • 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 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(error)

      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, A>

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

    • 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

      Returns Option<A>

      An Option containing the value if present, None otherwise

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

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

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods