scats/dist/array-iterable.d.ts

Useful scala classes in typescript

import { Collection, HashMap, Option } from './index.js';
export declare abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implements Iterable<T> {
    [Symbol.iterator](): Iterator<T, T | undefined, undefined>;
    abstract get toArray(): Array<T>;
    protected abstract fromArray(array: T[]): C;
    foreach<U>(job: (item: T) => U): void;
    contains(item: T): boolean;
    forall(p: (item: T) => boolean): boolean;
    exists(p: (item: T) => boolean): boolean;
    find(p: (item: T) => boolean): Option<T>;
    count(p: (item: T) => boolean): number;
    get isEmpty(): boolean;
    get nonEmpty(): boolean;
    get size(): number;
    reduce(op: (i1: T, i2: T) => T): T;
    reduceOption(op: (i1: T, i2: T) => T): Option<T>;
    get headOption(): Option<T>;
    get head(): T;
    get lastOption(): Option<T>;
    get last(): T;
    reduceLeft(op: (i1: T, i2: T) => T): T;
    reduceLeftOption(op: (i1: T, i2: T) => T): Option<T>;
    foldRight<B>(initial: B): (op: (next: T, acc: B) => B) => B;
    reduceRight(op: (i1: T, i2: T) => T): T;
    reduceRightOption(op: (i1: T, i2: T) => T): Option<T>;
    foldLeft<B>(initial: B): (op: (acc: B, next: T) => B) => B;
    fold<B>(initial: B): (op: (acc: B, next: T) => B) => B;
    groupBy<K>(field: (item: T) => K): HashMap<K, Collection<T>>;
    minBy(toNumber: (item: T) => number): T;
    minByOption(toNumber: (item: T) => number): Option<T>;
    maxBy(toNumber: (item: T) => number): T;
    maxByOption(toNumber: (item: T) => number): Option<T>;
    partition(p: (item: T) => boolean): [C, C];
    take(n: number): C;
    takeRight(n: number): C;
    takeWhile(p: (item: T) => boolean): C;
    drop(n: number): C;
    dropRight(n: number): C;
    dropWhile(p: (item: T) => boolean): C;
    sliding(length: number, step?: number): Collection<C>;
    grouped(length: number): Collection<C>;
    mkString(separator?: string): string;
    sum(elementToNum: (element: T) => number): number;
    filter(p: (item: T) => boolean): C;
    filterNot(p: (item: T) => boolean): C;
    splitAt(n: number): [C, C];
    span(p: (item: T) => boolean): [C, C];
    get init(): C;
    get tail(): C;
    groupMap<K, B>(key: (item: T) => K): (value: (_: T) => B) => HashMap<K, Collection<B>>;
    groupMapReduce<K, B>(key: (_: T) => K): GroupMapReduce2<T, K, B>;
    scan(z: T): (op: (acc: T, next: T) => T) => C;
    scanLeft(z: T): (op: (acc: T, next: T) => T) => C;
    scanRight(z: T): (op: (acc: T, next: T) => T) => C;
    get zipWithIndex(): Collection<[T, number]>;
    get tails(): Collection<C>;
    get inits(): Collection<C>;
}
export declare type GroupMapReduce3<K, B> = (reduce: (v1: B, v2: B) => B) => HashMap<K, B>;
export declare type GroupMapReduce2<T, K, B> = (f: (_: T) => B) => GroupMapReduce3<K, B>;