Iterable<E>.generate constructor

Iterable<E>.generate(
  1. int count, [
  2. E generator(
    1. int index
    )?
])

Creates an Iterable which generates its elements dynamically.

The generated iterable has count elements, and the element at index n is computed by calling generator(n). Values are not cached, so each iteration computes the values again.

If generator is omitted, it defaults to an identity function on integers (int x) => x, so it may only be omitted if the type parameter allows integer values. That is, if E is a super-type of int.

As an Iterable, Iterable.generate(n, generator)) is equivalent to const [0, ..., n - 1].map(generator).

Implementation

factory Iterable.generate(int count, [E generator(int index)?]) {
  // Always OK to omit generator when count is zero.
  if (count <= 0) return EmptyIterable<E>();
  if (generator == null) {
    // If generator is omitted, we generate integers.
    // If `E` does not allow integers, it's an error.
    Function id = _GeneratorIterable._id;
    if (id is! E Function(int)) {
      throw ArgumentError(
        "Generator must be supplied or element type must allow integers",
        "generator",
      );
    }
    generator = id;
  }
  return _GeneratorIterable<E>(count, generator);
}