Strong html

sdk/lib/html/html_common/css_class_set.dart

 // Copyright (c) 2012, 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 html_common;
 
 abstract class CssClassSetImpl implements CssClassSet {
 
   static final RegExp _validTokenRE = new RegExp(r'^\S+$');
 
@@ skipping 38 matching lines @@
   Iterator<String> get iterator => readClasses().iterator;
   // interface Iterable - END
 
   // interface Collection - BEGIN
   void forEach(void f(String element)) {
     readClasses().forEach(f);
   }
 
   String join([String separator = ""]) => readClasses().join(separator);
 
-  Iterable map(f(String element)) => readClasses().map(f);
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(String e)) =>

[Alan Knight, 2016/04/19 18:24:34]

Where does T come from? Is it the <String> in CssClassSet? Would it make more
sense to hard-code these as String rather than a generic parameter that's fixed?

[Jacob, 2016/04/19 21:50:45]

This is the correct form for the now generic map method.
CssClassSet doesn't specify this method... it is just inherited from Iterable.
Were you looking in the dartdocs or at the source code?

[Alan Knight, 2016/04/19 22:04:08]

I was thinking that because we get Iterable through CssClassSet, which
implements Set<String> that T would always be String. But that's not true. The
input is always String, but we could map it to anything. Disregard.

+      readClasses().map/*<T>*/(f);
 
   Iterable<String> where(bool f(String element)) => readClasses().where(f);
 
-  Iterable expand(Iterable f(String element)) => readClasses().expand(f);
+  Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(String element)) =>
+      readClasses().expand/*<T>*/(f);
 
   bool every(bool f(String element)) => readClasses().every(f);
 
   bool any(bool f(String element)) => readClasses().any(f);
 
   bool get isEmpty => readClasses().isEmpty;
 
   bool get isNotEmpty => readClasses().isNotEmpty;
 
   int get length => readClasses().length;
 
   String reduce(String combine(String value, String element)) {
     return readClasses().reduce(combine);
   }
 
-  dynamic fold(dynamic initialValue,
-      dynamic combine(dynamic previousValue, String element)) {
-    return readClasses().fold(initialValue, combine);
+  dynamic/*=T*/ fold/*<T>*/(var/*=T*/ initialValue,
+      dynamic/*=T*/ combine(var/*=T*/ previousValue, String element)) {
+    return readClasses().fold/*<T>*/(initialValue, combine);
   }
+
   // interface Collection - END
 
   // interface Set - BEGIN
   /**
    * Determine if this element contains the class [value].
    *
    * This is the Dart equivalent of jQuery's
    * [hasClass](http://api.jquery.com/hasClass/).
    */
   bool contains(Object value) {
@@ skipping 45 matching lines @@
     modify((s) => s.addAll(iterable.map(_validateToken)));
   }
 
   /**
    * Remove all classes specified in [iterable] from element.
    *
    * This is the Dart equivalent of jQuery's
    * [removeClass](http://api.jquery.com/removeClass/).
    */
   void removeAll(Iterable<Object> iterable) {
-    modify((s) => s.removeAll(iterable.map(_validateToken)));
+    modify((s) => s.removeAll(iterable));
   }
 
   /**
    * Toggles all classes specified in [iterable] on element.
    *
    * Iterate through [iterable]'s items, and add it if it is not on it, or
    * remove it if it is. This is the Dart equivalent of jQuery's
    * [toggleClass](http://api.jquery.com/toggleClass/).
    * If [shouldAdd] is true, then we always add all the classes in [iterable]
    * element. If [shouldAdd] is false then we always remove all the classes in
@@ skipping 17 matching lines @@
 
   bool containsAll(Iterable<Object> collection) =>
     readClasses().containsAll(collection);
 
   Set<String> intersection(Set<Object> other) =>
     readClasses().intersection(other);
 
   Set<String> union(Set<String> other) =>
     readClasses().union(other);
 
-  Set<String> difference(Set<String> other) =>
+  Set<String> difference(Set<Object> other) =>
     readClasses().difference(other);
 
   String get first => readClasses().first;
   String get last => readClasses().last;
   String get single => readClasses().single;
   List<String> toList({ bool growable: true }) =>
       readClasses().toList(growable: growable);
   Set<String> toSet() => readClasses().toSet();
   Iterable<String> take(int n) => readClasses().take(n);
   Iterable<String> takeWhile(bool test(String value)) =>
@@ skipping 17 matching lines @@
 
   /**
    * Helper method used to modify the set of css classes on this element.
    *
    *   f - callback with:
    *   s - a Set of all the css class name currently on this element.
    *
    *   After f returns, the modified set is written to the
    *       className property of this element.
    */
-  modify( f(Set<String> s)) {
+  modify(f(Set<String> s)) {
     Set<String> s = readClasses();
     var ret = f(s);
     writeClasses(s);
     return ret;
   }
 
   /**
    * Read the class names from the Element class property,
    * and put them into a set (duplicates are discarded).
    * This is intended to be overridden by specific implementations.
    */
   Set<String> readClasses();
 
   /**
    * Join all the elements of a set into one string and write
    * back to the element.
    * This is intended to be overridden by specific implementations.
    */
   void writeClasses(Set<String> s);
 }