Type Alias LazyList<A>

// Basic lazy evaluation
const result = LazyList([1, 2, 3, 4, 5])
  .map(x => x * 2)
  .filter(x => x > 5)
  .toArray() // [6, 8, 10]
Copy

// Infinite sequences with take
const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])
  .map(([a]) => a)
  .take(10)
  .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Copy

type LazyList<A extends Type> = {
    "[iterator]"(): Iterator<A>;
    concat(other: LazyList<A>): LazyList<A>;
    count(): number;
    drop(n: number): LazyList<A>;
    dropWhile(predicate: (a: A) => boolean): LazyList<A>;
    every(predicate: (a: A) => boolean): boolean;
    filter(predicate: (a: A) => boolean): LazyList<A>;
    find(predicate: (a: A) => boolean): Option<A>;
    first(): Option<A>;
    flatMap<B extends unknown>(f: (a: A) => LazyList<B>): LazyList<B>;
    forEach(f: (a: A) => void): void;
    last(): Option<A>;
    map<B extends unknown>(f: (a: A) => B): LazyList<B>;
    reduce<B extends unknown>(f: (acc: B, a: A) => B, initial: B): B;
    some(predicate: (a: A) => boolean): boolean;
    take(n: number): LazyList<A>;
    takeWhile(predicate: (a: A) => boolean): LazyList<A>;
    toArray(): A[];
    toList(): List<A>;
    zip<B extends unknown>(other: LazyList<B>): LazyList<[A, B]>;
}