Add Iterable.range, List.range and int.to.

sdk/lib/core/iterable.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.core;
 
 /**
  * An object that uses an [Iterator] to serve objects one at a time.
  *
  * You can iterate over all objects served by an Iterable object
@@ skipping 36 matching lines @@
    *
    * As an Iterable, [:new Iterable.generate(n, generator)):] is equivalent to
    * [:const [0, ..., n - 1].map(generator):]
    */
   factory Iterable.generate(int count, [E generator(int index)]) {
     if (count <= 0) return new EmptyIterable<E>();
     return new _GeneratorIterable<E>(count, generator);
   }
 
   /**
+   * Create an `Iterable<int>` iterating from `from` to `to`, inclusive.
+   *
+   * The iteration starts with `from` as the first value, and then
+   * progresses towards `to` in increments of `step`, and stops when reaching
+   * or overshooting `to`. If it hits `to` the `to` value is included,

[floitsch, 2014/09/09 09:37:14]

Strongly oppose.
We have a getRange in this class that has different semantics.

+   * otherwise it isn't.
+   *
+   * If `to` is less than `from`, the values are in decreasing order.
+   *
+   * The [step] value must always be positive. It defaults to `1`.
+   */
+  static Iterable<int> range(int from, int to, {int step: 1}) {
+    if (step <= 0) {
+      throw new RangeError.value("Step must be positive, was $step");
+    }
+    final int delta = to - from;
+    if (delta < 0) {
+      step = -step;
+    }
+    final int steps = delta ~/ step + 1;
+    return new Iterable<int>.generate(steps, (n) => from + n * step);
+  }
+
+  /**
    * Returns a new `Iterator` that allows iterating the elements of this
    * `Iterable`.
    */
   Iterator<E> get iterator;
 
   /**
    * Returns a new lazy [Iterable] with elements that are created by
    * calling `f` on the elements of this `Iterable`.
    *
    * This method returns a view of the mapped elements. As long as the
@@ skipping 300 matching lines @@
  */
 abstract class BidirectionalIterator<E> implements Iterator<E> {
   /**
    * Move back to the previous element.
    *
    * Returns true and updates [current] if successful. Returns false
    * and sets [current] to null if there is no previous element.
    */
   bool movePrevious();
 }