Fix strong mode warnings.

lib/src/canonicalized_map.dart

 // Copyright (c) 2014, 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 'utils.dart';
 
+typedef C _Canonicalize<C, K>(K key);
+
+typedef bool _IsValidKey(Object key);
+
 /// A map whose keys are converted to canonical values of type `C`.
 ///
 /// This is useful for using case-insensitive String keys, for example. It's
 /// more efficient than a [LinkedHashMap] with a custom equality operator
 /// because it only canonicalizes each key once, rather than doing so for each
 /// comparison.
 ///
 /// By default, `null` is allowed as a key. It can be forbidden via the
 /// `isValidKey` parameter.
 class CanonicalizedMap<C, K, V> implements Map<K, V> {
-  final Function _canonicalize;
+  final _Canonicalize<C, K> _canonicalize;
 
-  final Function _isValidKeyFn;
+  final _IsValidKey _isValidKeyFn;
 
   final _base = new Map<C, Pair<K, V>>();
 
   /// Creates an empty canonicalized map.
   ///
   /// The [canonicalize] function should return the canonical value for the
   /// given key. Keys with the same canonical value are considered equivalent.
   ///
   /// The [isValidKey] function is called before calling [canonicalize] for
   /// methods that take arbitrary objects. It can be used to filter out keys
@@ skipping 13 matching lines @@
   /// that can't be canonicalized.
   CanonicalizedMap.from(Map<K, V> other, C canonicalize(K key),
                         {bool isValidKey(Object key)})
       : _canonicalize = canonicalize,
         _isValidKeyFn = isValidKey {
     addAll(other);
   }
 
   V operator [](Object key) {
     if (!_isValidKey(key)) return null;
-    var pair = _base[_canonicalize(key)];
+    var pair = _base[_canonicalize(key as K)];
     return pair == null ? null : pair.last;
   }
 
   void operator []=(K key, V value) {
     if (!_isValidKey(key)) return;
     _base[_canonicalize(key)] = new Pair(key, value);
   }
 
   void addAll(Map<K, V> other) {
     other.forEach((key, value) => this[key] = value);
   }
 
   void clear() {
     _base.clear();
   }
 
   bool containsKey(Object key) {
     if (!_isValidKey(key)) return false;
-    return _base.containsKey(_canonicalize(key));
+    return _base.containsKey(_canonicalize(key as K));
   }
 
   bool containsValue(Object value) =>
       _base.values.any((pair) => pair.last == value);
 
   void forEach(void f(K key, V value)) {
     _base.forEach((key, pair) => f(pair.first, pair.last));
   }
 
   bool get isEmpty => _base.isEmpty;
 
   bool get isNotEmpty => _base.isNotEmpty;
 
   Iterable<K> get keys => _base.values.map((pair) => pair.first);
 
   int get length => _base.length;
 
   V putIfAbsent(K key, V ifAbsent()) {
     return _base.putIfAbsent(_canonicalize(key),
         () => new Pair(key, ifAbsent())).last;
   }
 
   V remove(Object key) {
     if (!_isValidKey(key)) return null;
-    var pair = _base.remove(_canonicalize(key));
+    var pair = _base.remove(_canonicalize(key as K));
     return pair == null ? null : pair.last;
   }
 
   Iterable<V> get values => _base.values.map((pair) => pair.last);
 
   String toString() => Maps.mapToString(this);
 
   bool _isValidKey(Object key) => (key == null || key is K) &&
       (_isValidKeyFn == null || _isValidKeyFn(key));
 }