Add Stream.fromIterable

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;
 
 /**
  * The [Iterable] interface allows to get an [Iterator] out of an
  * [Iterable] object.
  *
  * This interface is used by the for-in construct to iterate over an
  * [Iterable] object.
  * The for-in construct takes an [Iterable] object at the right-hand
  * side, and calls its [iterator] method to get an [Iterator] on it.
  *
  * A user-defined class that implements the [Iterable] interface can
  * be used as the right-hand side of a for-in construct.
  */
 abstract class Iterable<E> {
   const Iterable();
 
+  factory Iterable.generate(int count, E generator(int index)) {

[Sean Eagan, 2013/01/09 14:15:20]

Once we have a some way to get a integer range, I don't think we will need this
constructor:

range(10).mappedBy(f);

and then for Streams:

new Stream.fromIterable(range(10).mappedBy(f)); // or
new Stream.fromIterable(range(10)).mappedBy(f);

+    return new _GeneratorIterable<E>(count, generator);
+  }
+
   /**
    * Returns an [Iterator] that iterates over this [Iterable] object.
    */
   Iterator<E> get iterator;
 
   /**
    * Returns a lazy [Iterable] where each element [:e:] of [this] is replaced
    * by the result of [:f(e):].
    *
    * This method returns a view of the mapped elements. As long as the
@@ skipping 549 matching lines @@
       _hasSkipped = true;
       while (_iterator.moveNext()) {
         if (!_f(_iterator.current)) return true;
       }
     }
     return _iterator.moveNext();
   }
 
   E get current => _iterator.current;
 }
+
+
+typedef E _Generator<E>(int index);
+
+class _GeneratorIterable<E> extends Iterable<E> {
+  final int _count;
+  final _Generator<E> _generator;
+  _GeneratorIterable(this._count, this._generator);
+  Iterator<E> get iterator => new _GeneratorIterator(_count, _generator);
+}
+
+class _GeneratorIterator<E> implements Iterator<E> {
+  final int _count;
+  final _Generator<E> _generator;
+  int _index = 0;
+  E _current;
+
+  _GeneratorIterator(this._count, this._generator);
+
+  bool moveNext() {
+    if (_index < _count) {
+      _current = _generator(_index);
+      _index++;
+      return true;
+    } else {
+      _current = null;
+      return false;
+    }
+  }
+
+  E get current => _current;
+}