Options
All
  • Public
  • Public/Protected
  • All
Menu

Class EnhancedGenerator<T, TReturn, TNext>

Utilities to create and use generators which can be manipulated in various ways.

Most methods come both as instance (prototype) methods and as static methods. They provide equivalent functionality, but the static methods allow use on Iterator and Iterable objects without first converting to a generator.

The [[EnhancedGenerator.enhance]] method will add additional instance methods to an ordinary generator's prototype (a new prototype, not modifying any global prototype!). It can also be used to convert Iterator and Iterable objects to EnhancedGenerator.

For methods which return a EnhancedGenerator, care is take to propagate any Generator.throw and Generator.return calls to any supplied generators, so they can properly terminate.

The exception is EnhancedGenerator.flat (and by extension, EnhancedGenerator.flatMap), which cannot know what nested generators they might encounter in the future. Any generators encountered so far will be terminated, however.

Type parameters

  • T

    the type of values returned in the iteration result.

  • TReturn

    the type of values returned in the iteration result when the generator terminates

  • TNext

    the type of value which can be passed to .next(val).

Hierarchy

  • Enhancements<T, TReturn, TNext, sync>
    • EnhancedGenerator

Implements

  • Generator<T, TReturn, TNext>
  • Iterable<T>
  • Iterator<T, TReturn, TNext>

Index

Constructors

constructor

  • Type parameters

    • T

    • TReturn

    • TNext

    Returns EnhancedGenerator<T, TReturn, TNext>

Properties

[toStringTag]

[toStringTag]: "EnhancedGenerator"

Methods

asArray

  • asArray(): T[]
  • Return all of the values from this generator as an array. You do not want to call this on an infinite generator (for obvious reasons); consider using [[Enhancements.slice|Generator.slice]] or [[Enhancements.limit|Generator.limit]] to limit the size before calling this.

    Returns T[]

concat

  • concat<T, TReturn, TNext>(...gens: (Generator<T, TReturn, TNext> | Iterator<T, TReturn, TNext> | Iterable<T> | Enhancements<T, TReturn, TNext, "sync">)[]): EnhancedGenerator<T, void | TReturn, TNext>
  • Concatenates generators (or iterators or iterables).

    Ensures that any supplied generators are terminated when this is terminated.

    Type parameters

    • T

    • TReturn

    • TNext

    Parameters

    • Rest ...gens: (Generator<T, TReturn, TNext> | Iterator<T, TReturn, TNext> | Iterable<T> | Enhancements<T, TReturn, TNext, "sync">)[]

      zero or more additional Genable to provide values.

    Returns EnhancedGenerator<T, void | TReturn, TNext>

every

  • every(p: (v: T, idx: number) => boolean, thisArg?: any): boolean
  • Returns false and terminates this generator if the predicate is false for any of the generator's yielded values.

    If the generator terminates without having failed the predicate, true is returned.

    Parameters

    • p: (v: T, idx: number) => boolean

      predicate to apply to each yielded value.

        • (v: T, idx: number): boolean
        • Parameters

          • v: T
          • idx: number

          Returns boolean

    • Optional thisArg: any

      Optional value to supply as context (this) for the predicate

    Returns boolean

filter

  • filter(f: (v: T, idx: number) => boolean, thisArg?: any): EnhancedGenerator<T, TReturn, TNext>
  • Return a new enhanced [[Enhancements|Generator]] that yields only the values that satisfy the predicate f.

    f receives the value and a sequential index.

    Parameters

    • f: (v: T, idx: number) => boolean
        • (v: T, idx: number): boolean
        • Parameters

          • v: T
          • idx: number

          Returns boolean

    • Optional thisArg: any

      Optional context to be passed as this to the predicate.

    Returns EnhancedGenerator<T, TReturn, TNext>

flat

  • flat<D>(depth?: D): any
  • Flatten the values yielded by this generator to level depth. Produces a generator that yields the individual values at each level in depth-first order. Any iterable (including Array) or iterator will be traversed and its values yielded.

    The return type is currently over-broad

    Type parameters

    • D: number

    Parameters

    • Optional depth: D

      (default = 1)

    Returns any

flatMap

  • flatMap<D>(f: (v: T, idx: number) => any, depth?: D): any
  • Flatten the values yielded by applying the function to the values yielded by the generator to level depth. Produces a generator that yields the individual values at each level in depth-first order. Any iterable (including Array) or iterator will be traversed and its values yielded.

    The return type is currently over-broad

    Type parameters

    • D: number = 1

    Parameters

    • f: (v: T, idx: number) => any
        • (v: T, idx: number): any
        • Parameters

          • v: T
          • idx: number

          Returns any

    • Optional depth: D

    Returns any

forEach

  • forEach(f: (v: T, idx: number) => void, thisArg?: any): void
  • Operate on each value produced by this generator. f is called with two values, the value yielded by this generator and a sequential index.

    Parameters

    • f: (v: T, idx: number) => void
        • (v: T, idx: number): void
        • Parameters

          • v: T
          • idx: number

          Returns void

    • Optional thisArg: any

      Value to be supplied as context this for function f.

    Returns void

join

  • join(sep?: string): string

limit

  • Limit the number of values that can be generated. A RangeError is thrown if this limit is exceeded. See [[IEnhacements.slice|Generator.slice]] if you want to truncate.

    Parameters

    • max: number

    Returns EnhancedGenerator<T, TReturn, TNext>

map

  • map<V>(f: (v: T, idx: number) => V, thisArg?: any): EnhancedGenerator<V, TReturn, TNext>
  • Apply the function to each value yielded by this generator. It is called with two arguments, the value yielded, and a sequential index. The return value is a generator that yields the values produced by the function.

    Type parameters

    • V

    Parameters

    • f: (v: T, idx: number) => V
        • (v: T, idx: number): V
        • Parameters

          • v: T
          • idx: number

          Returns V

    • Optional thisArg: any

      Optional value to be supplied as context this for function f.

    Returns EnhancedGenerator<V, TReturn, TNext>

reduce

  • reduce<A, T, TReturn, TNext>(f: (acc: A | T, v: T) => A): A
  • reduce<A, T, TReturn, TNext>(f: (acc: A, v: T) => A, init: A): A
  • Like Array.prototype.reduce, but the 3rd argument to the reducing function ("array") is omitted because there is no array.

    Type parameters

    • A

    • T

    • TReturn

    • TNext

    Parameters

    • f: (acc: A | T, v: T) => A
        • (acc: A | T, v: T): A
        • Parameters

          • acc: A | T
          • v: T

          Returns A

    Returns A

  • Like Array.prototype.reduce, but the 3rd argument to the reducing function ("array") is omitted because there is no array.

    Type parameters

    • A

    • T

    • TReturn = T

    • TNext = T

    Parameters

    • f: (acc: A, v: T) => A
        • (acc: A, v: T): A
        • Parameters

          • acc: A
          • v: T

          Returns A

    • init: A

    Returns A

repeat

  • Returns a new generator that repeats the supplied value after this generator completes.

    Type parameters

    • N

    Parameters

    • value: N

      the value to repeat

    • Optional repetitions: number

      The number repetitions; the default is infinite.

    Returns EnhancedGenerator<T | N, void, TNext>

repeatLast

slice

  • slice(start?: number, end?: number): EnhancedGenerator<T, undefined | TReturn, TNext>
  • Return a new enhanced [[Enhancements|Generator]] that only yields the indicated values, skipping start initial values and continuing until the end.

    Parameters

    • Optional start: number
    • Optional end: number

    Returns EnhancedGenerator<T, undefined | TReturn, TNext>

some

  • some<T>(p: (v: T, idx: number) => boolean, thisArg?: any): boolean
  • Returns true and terminates the generator if the predicate is true for any of the generator's yielded values.

    If the generator terminates without having satisfied the predicate, false is returned.

    Type parameters

    • T

    Parameters

    • p: (v: T, idx: number) => boolean

      predicate to apply to each yielded value.

        • (v: T, idx: number): boolean
        • Parameters

          • v: T
          • idx: number

          Returns boolean

    • Optional thisArg: any

      Optional value to supply as context (this) for the predicate

    Returns boolean

sort

  • sort(cmp?: (a: T, b: T) => number): T[]
  • Sorts the supplied values and returns a sorted array.

    Parameters

    • Optional cmp: (a: T, b: T) => number

      a comparison function

        • (a: T, b: T): number
        • Parameters

          • a: T
          • b: T

          Returns number

    Returns T[]

zip

  • Combines this generator with additional ones, returning a generator that produces a tuple with each of their results, with this generator's result first.

    Terminates when any generator terminates. To get other behaviors, use with Generator.repeat or Generator.repeatLast.

    Type parameters

    • G: (Generator<T, TReturn, TNext> | Iterator<T, TReturn, TNext> | Iterable<T> | Enhancements<T, TReturn, TNext, "sync">)[]

    • T

    • TReturn

    • TNext

    Parameters

    • Rest ...gens: G

    Returns EnhancedGenerator<T[], TReturn, TNext>

Generated using TypeDoc