Fix strong mode warnings.

lib/src/wrappers.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.
 
 import "dart:collection";
 import "dart:math" as math;
 
 import "unmodifiable_wrappers.dart";
 
+typedef K _KeyForValue<K, V>(V value);
+
 /// A base class for delegating iterables.
 ///
 /// Subclasses can provide a [_base] that should be delegated to. Unlike
 /// [DelegatingIterable], this allows the base to be created on demand.
 abstract class _DelegatingIterableBase<E> implements Iterable<E> {
   Iterable<E> get _base;
 
   const _DelegatingIterableBase();
 
   bool any(bool test(E element)) => _base.any(test);
 
   bool contains(Object element) => _base.contains(element);
 
   E elementAt(int index) => _base.elementAt(index);
 
   bool every(bool test(E element)) => _base.every(test);
 
-  Iterable expand(Iterable f(E element)) => _base.expand(f);
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(E element)) =>
+      _base.expand(f);
 
   E get first => _base.first;
 
   E firstWhere(bool test(E element), {E orElse()}) =>
       _base.firstWhere(test, orElse: orElse);
 
-  fold(initialValue, combine(previousValue, E element)) =>
+  /*=T*/ fold/*<T>*/(
+          /*=T*/ initialValue,
+          /*=T*/ combine(/*=T*/ previousValue, E element)) =>
       _base.fold(initialValue, combine);
 
   void forEach(void f(E element)) => _base.forEach(f);
 
   bool get isEmpty => _base.isEmpty;
 
   bool get isNotEmpty => _base.isNotEmpty;
 
   Iterator<E> get iterator => _base.iterator;
 
   String join([String separator = ""]) => _base.join(separator);
 
   E get last => _base.last;
 
   E lastWhere(bool test(E element), {E orElse()}) =>
       _base.lastWhere(test, orElse: orElse);
 
   int get length => _base.length;
 
-  Iterable map(f(E element)) => _base.map(f);
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) => _base.map(f);
 
   E reduce(E combine(E value, E element)) => _base.reduce(combine);
 
   E get single => _base.single;
 
   E singleWhere(bool test(E element)) => _base.singleWhere(test);
 
   Iterable<E> skip(int n) => _base.skip(n);
 
   Iterable<E> skipWhile(bool test(E value)) => _base.skipWhile(test);
@@ skipping 319 matching lines @@
   ///
   /// That is, the returned set contains all the elements of this [Set] and all
   /// the elements of [other].
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<E> union(Set<E> other) => toSet()..addAll(other);
 }
 
 /// Creates a modifiable [Set] view of the values of a [Map].
-/// 
+///
 /// The `Set` view assumes that the keys of the `Map` can be uniquely determined
 /// from the values. The `keyForValue` function passed to the constructor finds
 /// the key for a single value. The `keyForValue` function should be consistent
 /// with equality. If `value1 == value2` then `keyForValue(value1)` and
 /// `keyForValue(value2)` should be considered equal keys by the underlying map,
 /// and vice versa.
 ///
 /// Modifying the set will modify the underlying map based on the key returned
 /// by `keyForValue`.
 ///
 /// If the `Map` contents are not compatible with the `keyForValue` function,
 /// the set will not work consistently, and may give meaningless responses or do
 /// inconsistent updates.
 ///
 /// This set can, for example, be used on a map from database record IDs to the
 /// records. It exposes the records as a set, and allows for writing both
 /// `recordSet.add(databaseRecord)` and `recordMap[id]`.
 ///
 /// Effectively, the map will act as a kind of index for the set.
 class MapValueSet<K, V> extends _DelegatingIterableBase<V> implements Set<V> {
   final Map<K, V> _baseMap;
-  final Function _keyForValue;
+  final _KeyForValue<K, V> _keyForValue;
 
   /// Creates a new [MapValueSet] based on [base].
   ///
   /// [keyForValue] returns the key in the map that should be associated with
   /// the given value. The set's notion of equality is identical to the equality
   /// of the return values of [keyForValue].
   MapValueSet(Map<K, V> base, K keyForValue(V value))
       : _baseMap = base,
         _keyForValue = keyForValue;
 
   Iterable<V> get _base => _baseMap.values;
 
   bool contains(Object element) {
     if (element != null && element is! V) return false;
-    return _baseMap.containsKey(_keyForValue(element));
+    var key = _keyForValue(element as V);
+
+    return _baseMap.containsKey(key);
   }
 
   bool get isEmpty => _baseMap.isEmpty;
 
   bool get isNotEmpty => _baseMap.isNotEmpty;
 
   int get length => _baseMap.length;
 
   String toString() => toSet().toString();
 
@@ skipping 25 matching lines @@
 
   /// Returns a new set which is the intersection between [this] and [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] that are
   /// also elements of [other] according to `other.contains`.
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<V> intersection(Set<Object> other) => where(other.contains).toSet();
 
-  V lookup(Object element) => _baseMap[_keyForValue(element)];
+  V lookup(Object element) {
+    if (element != null && element is! V) return null;
+    var key = _keyForValue(element as V);
 
-  bool remove(Object value) {
-    if (value != null && value is! V) return false;
-    var key = _keyForValue(value);
+    return _baseMap[key];
+  }
+
+  bool remove(Object element) {
+    if (element != null && element is! V) return false;
+    var key = _keyForValue(element as V);
+
     if (!_baseMap.containsKey(key)) return false;
     _baseMap.remove(key);
     return true;
   }
 
   void removeAll(Iterable<Object> elements) => elements.forEach(remove);
 
   void removeWhere(bool test(V element)) {
     var toRemove = [];
     _baseMap.forEach((key, value) {
       if (test(value)) toRemove.add(key);
     });
     toRemove.forEach(_baseMap.remove);
   }
 
   void retainAll(Iterable<Object> elements) {
     var valuesToRetain = new Set<V>.identity();
     for (var element in elements) {
       if (element != null && element is! V) continue;
-      var key = _keyForValue(element);
+      var key = _keyForValue(element as V);
+
       if (!_baseMap.containsKey(key)) continue;
       valuesToRetain.add(_baseMap[key]);
     }
 
     var keysToRemove = [];
     _baseMap.forEach((k, v) {
       if (!valuesToRetain.contains(v)) keysToRemove.add(k);
     });
     keysToRemove.forEach(_baseMap.remove);
   }
 
   void retainWhere(bool test(V element)) =>
       removeWhere((element) => !test(element));
 
   /// Returns a new set which contains all the elements of [this] and [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] and all
   /// the elements of [other].
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<V> union(Set<V> other) => toSet()..addAll(other);
 }