Change List/Set/Map/Queue.from constructrs to accept any iterable.

sdk/lib/collection/hash_set.dart

 // Copyright (c) 2013, 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.collection;
 
 /** Common parts of [HashSet] and [LinkedHashSet] implementations. */
 abstract class _HashSetBase<E> extends SetBase<E> {
 
   // The following two methods override the ones in SetBase.
@@ skipping 53 matching lines @@
    * the objects' intrinsic [Object.operator==] and [Object.hashCode].
    *
    * If [isValidKey] is omitted, it defaults to testing if the object is an
    * [E] instance.
    *
    * If you supply one of [equals] and [hashCode],
    * you should generally also to supply the other.
    * An example would be using [identical] and [identityHashCode],
    * which is equivalent to using the shorthand [LinkedSet.identity]).
    */
-  external factory HashSet({ bool equals(E e1, E e2),
-                             int hashCode(E e),
-                             bool isValidKey(potentialKey) });
+  external factory HashSet({bool equals(E e1, E e2),
+                            int hashCode(E e),
+                            bool isValidKey(potentialKey)});
 
   /**
    * Creates an unordered identity-based set.
    *
    * Effectively a shorthand for:
    *
    *     new HashSet(equals: identical, hashCode: identityHashCodeOf)
    */
   external factory HashSet.identity();
 
   /**
-   * Create a hash set containing the elements of [iterable].
+   * Create a hash set containing all of [elements].

[floitsch, 2015/01/05 14:45:30]

all [elements]. ?

[Lasse Reichstein Nielsen, 2015/01/06 10:14:45]

Done.

    *
    * Creates a hash set as by `new HashSet<E>()` and adds each element of
-   * `iterable` to this set in the order they are iterated.
+   * `elements` to this set in the order they are iterated.
+   *
+   * All the [elements] should be assignable to [E].

[Søren Gjesse, 2015/01/05 15:35:15]

[E] -> `E`

[Lasse Reichstein Nielsen, 2015/01/06 10:14:45]

Why? The [E] is in scope, so we might as well link to it.

[Søren Gjesse, 2015/01/06 12:09:05]

Good - I am not exactly clear on the dartdoc scoping rules thought they where
method specific and that [E] would not link to anything.

[Lasse Reichstein Nielsen, 2015/01/07 07:56:45]

The spec tries to specify how references in DartDoc are resolved, but it's
somewhat vague.

In practice it *should* work so that any name that can be referenced from
anywhere inside the documented declaration, is in scope.
The type parameter of a class should be in scope for DartDoc in the class
documentation and in any DartDoc inside the class (I don't think we make
exceptions for static functions).

A type parameter can be used in a generative constructor, so it should be in
scope here. I haven't checked if it actually works with the DartDoc tool,
though, but if not, I'll have to file a bug report :)

+   * The `elements` iterable itself may have any element type, so this
+   * constructor can be used to down-cast a `Set`, for example as:
+   *
+   *     Set<SuperType> superSet = ...;
+   *     Set<SubType> subSet =
+   *         new HashSet<SubType>.from(superSet.where((e) => e is SubType));
    */
-  factory HashSet.from(Iterable<E> iterable) {
-    return new HashSet<E>()..addAll(iterable);
+  factory HashSet.from(Iterable elements) {
+    HashSet<E> result = new HashSet<E>();
+    for (E e in elements) result.add(e);
+    return result;
   }
 
   /**
    * Provides an iterator that iterates over the elements of this set.
    *
    * The order of iteration is unspecified,
    * but consistent between changes to the set.
    */
   Iterator<E> get iterator;
 }