Make core libraries use generic method syntax.

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;
 
 /**
  * A collection of values, or "elements", that can be accessed sequentially.
  *
  * The elements of the iterable are accessed by getting an [Iterator]
@@ skipping 136 matching lines @@
    * This method returns a view of the mapped elements. As long as the
    * returned [Iterable] is not iterated over, the supplied function [f] will
    * not be invoked. The transformed elements will not be cached. Iterating
    * multiple times over the returned [Iterable] will invoke the supplied
    * function [f] multiple times on the same element.
    *
    * Methods on the returned iterable are allowed to omit calling `f`
    * on any element where the result isn't needed.
    * For example, [elementAt] may call `f` only once.
    */
-  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E e)) =>
-      new MappedIterable<E, dynamic/*=T*/>(this, f);
+  Iterable<T> map<T>(T f(E e)) =>
+      new MappedIterable<E, T>(this, f);
 
   /**
    * Returns a new lazy [Iterable] with all elements that satisfy the
    * predicate [test].
    *
    * The matching elements have the same order in the returned iterable
    * as they have in [iterator].
    *
    * This method returns a view of the mapped elements.
    * As long as the returned [Iterable] is not iterated over,
@@ skipping 17 matching lines @@
    *
    *     var pairs = [[1, 2], [3, 4]];
    *     var flattened = pairs.expand((pair) => pair).toList();
    *     print(flattened); // => [1, 2, 3, 4];
    *
    *     var input = [1, 2, 3];
    *     var duplicated = input.expand((i) => [i, i]).toList();
    *     print(duplicated); // => [1, 1, 2, 2, 3, 3]
    *
    */
-  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(E element)) =>
-      new ExpandIterable<E, dynamic/*=T*/>(this, f);
+  Iterable<T> expand<T>(Iterable<T> f(E element)) =>
+      new ExpandIterable<E, T>(this, f);
 
   /**
    * Returns true if the collection contains an element equal to [element].
    *
    * This operation will check each element in order for being equal to
    * [element], unless it has a more efficient way to find an element
    * equal to [element].
    *
    * The equality used to determine whether [element] is equal to an element of
    * the iterable defaults to the [Object.==] of the element.
@@ skipping 65 matching lines @@
    *     for (E element in this) {
    *       value = combine(value, element);
    *     }
    *     return value;
    *
    * Example of calculating the sum of an iterable:
    *
    *     iterable.fold(0, (prev, element) => prev + element);
    *
    */
-  dynamic/*=T*/ fold/*<T>*/(var/*=T*/ initialValue,
-               dynamic/*=T*/ combine(var/*=T*/ previousValue, E element)) {
+  T fold<T>(T initialValue,

[floitsch, 2016/12/13 12:42:25]

one line?

[Lasse Reichstein Nielsen, 2016/12/13 14:28:03]

Done.

+               T combine(T previousValue, E element)) {
     var value = initialValue;
     for (E element in this) value = combine(value, element);
     return value;
   }
 
   /**
    * Checks whether every element of this iterable satisfies [test].
    *
    * Checks every element in iteration order, and returns `false` if
    * any of them make [test] return `false`, otherwise returns `true`.
@@ skipping 352 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();
 }