FuncType - v1.4.1
    Preparing search index...

    Interface LazyList<A>

    LazyList provides lazy evaluation for list operations. Operations are deferred until the list is materialized.

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

    // 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]
    interface LazyList<out A extends Type> {
        _tag: "LazyList";
        "[toStringTag]": string;
        get head(): A | undefined;
        get headOption(): Option<A>;
        get init(): LazyList<A>;
        get last(): A | undefined;
        get lastOption(): Option<A>;
        get tail(): LazyList<A>;
        "[iterator]"(): Iterator<A>;
        concat<B extends unknown>(other: LazyList<B>): LazyList<A | B>;
        count(): number;
        distinct(): LazyList<A>;
        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>;
        flatMap<B extends unknown>(f: (a: A) => LazyList<B>): LazyList<B>;
        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: (a: A) => B): LazyList<B>;
        pipe<U extends unknown>(f: (value: LazyList) => U): U;
        reduce<B extends unknown>(f: (acc: B, a: A) => B, initial: B): B;
        reverse(): LazyList<A>;
        serialize(): SerializationMethods<LazyList<A>>;
        some(predicate: (a: A) => boolean): boolean;
        take(n: number): LazyList<A>;
        takeRight(n: number): LazyList<A>;
        takeWhile(predicate: (a: A) => boolean): LazyList<A>;
        toArray(): A[];
        toJSON(): SerializableEnvelope;
        toList(): List<A>;
        toString(): string;
        zip<B extends unknown>(other: LazyList<B>): LazyList<[A, B]>;
        zipWithIndex(): LazyList<[A, number]>;
    }

    Type Parameters

    Hierarchy (View Summary)

    Index

    Properties

    _tag [toStringTag]

    Accessors

    head headOption init last lastOption tail

    Methods

    [iterator] concat count distinct drop dropWhile every filter find flatMap fold foldLeft foldRight forEach map pipe reduce reverse serialize some take takeRight takeWhile toArray toJSON toList toString zip zipWithIndex

    Properties

    Readonly_tag

    _tag: "LazyList"
    "[toStringTag]": string

    Accessors

    • get head(): A | undefined

      Returns A | undefined

    • get last(): A | undefined

      Returns A | undefined

    Methods

    • Returns Iterator<A>

    • Concatenate with another lazy list, possibly widening (Scala: ++[B >: A]).

      Type Parameters

      • B extends unknown

      Parameters

      Returns LazyList<A | B>

    • Returns number

    • Parameters

      • predicate: (a: A) => boolean

      Returns LazyList<A>

    • Parameters

      • predicate: (a: A) => boolean

      Returns boolean

    • Parameters

      • predicate: (a: A) => boolean

      Returns LazyList<A>

    • Parameters

      • predicate: (a: A) => boolean

      Returns Option<A>

    • Type Parameters

      • B

      Parameters

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

      Returns B

    • 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

    • Parameters

      • f: (a: A) => void

      Returns void

    • Type Parameters

      • B extends unknown

      Parameters

      • f: (a: A) => B

      Returns LazyList<B>

    • Pipes the value through the provided function

      Type Parameters

      • U extends unknown

        The return type of the function

      Parameters

      • f: (value: LazyList) => U

        The function to apply to the value

      Returns U

      The result of applying the function to the value

    • Type Parameters

      • B extends unknown

      Parameters

      • f: (acc: B, a: A) => B
      • initial: B

      Returns B

    • Parameters

      • predicate: (a: A) => boolean

      Returns boolean

    • Parameters

      • predicate: (a: A) => boolean

      Returns LazyList<A>

    • Returns A[]

    • Custom JSON serialization. Returns the canonical @functype-marked envelope object so native JSON.stringify (and the rest of the JSON toJSON protocol) emits a round-trip-able shape that Serialization.deserialize can reconstruct.

      Added in 1.2.0. Concrete types narrow the return to their specific marker/tag literals.

      Returns SerializableEnvelope

    • Returns a string representation of an object.

      Returns string

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods