Type Alias List<A>

List: {
    "[iterator]": () => Iterator<A>;
    add: (item: A) => List<A>;
    concat: (other: List<A>) => List<A>;
    count: (p: (x: A) => boolean) => number;
    drop: (n: number) => List<A>;
    dropRight: (n: number) => List<A>;
    dropWhile: (p: (a: A) => boolean) => List<A>;
    exists: (p: (a: A) => boolean) => boolean;
    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>;
    flatMap: <B>(f: (a: A) => IterableType<B>) => List<B>;
    flatMapAsync: <B>(
        f: (a: A) => PromiseLike<IterableType<B>>,
    ) => PromiseLike<List<B>>;
    flatten: <B>() => List<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;
    get: (index: number) => Option<A>;
    head: A | undefined;
    headOption: Option<A>;
    isEmpty: boolean;
    length: number;
    map: <B>(f: (a: A) => B) => List<B>;
    reduce: (f: (prev: A, curr: A) => A) => A;
    reduceRight: (f: (prev: A, curr: A) => A) => A;
    remove: (value: A) => List<A>;
    removeAt: (index: number) => List<A>;
    toArray: <B = A>() => B[];
    toList: () => List<A>;
    toSet: () => Set<A>;
    toString: () => string;
    toValue: () => { _tag: "List"; value: A[] };
    filter<S>(predicate: (a: A) => a is S): List<S>;
    filter(predicate: (a: A) => unknown): List<A>;
} & IterableType<A> & AsyncFunctor<A> & Typeable<"List">