Rename mappedBy to map.

sdk/lib/svg/dartium/svg_dartium.dart

 library svg;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:html_common';
 import 'dart:nativewrappers';
 // DO NOT EDIT
 // Auto-generated dart:svg library.
 
@@ skipping 3945 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(Length element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(Length element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(Length element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(Length element)) => map(f);
 
   Iterable<Length> where(bool f(Length element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
 
   List<Length> toList() => new List<Length>.from(this);
   Set<Length> toSet() => new Set<Length>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Length> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<Length> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<Length> takeWhile(bool test(Length value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Length> skipWhile(bool test(Length value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   Length firstMatching(bool test(Length value), { Length orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   Length lastMatching(bool test(Length value), {Length orElse()}) {
@@ skipping 725 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(Number element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(Number element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(Number element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(Number element)) => map(f);
 
   Iterable<Number> where(bool f(Number element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
 
   List<Number> toList() => new List<Number>.from(this);
   Set<Number> toSet() => new Set<Number>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Number> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<Number> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<Number> takeWhile(bool test(Number value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Number> skipWhile(bool test(Number value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   Number firstMatching(bool test(Number value), { Number orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   Number lastMatching(bool test(Number value), {Number orElse()}) {
@@ skipping 1143 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(PathSeg element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(PathSeg element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(PathSeg element)) => map(f);
 
   Iterable<PathSeg> where(bool f(PathSeg element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
 
   List<PathSeg> toList() => new List<PathSeg>.from(this);
   Set<PathSeg> toSet() => new Set<PathSeg>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<PathSeg> skipWhile(bool test(PathSeg value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) {
@@ skipping 983 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(String element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(String element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(String element)) => map(f);
 
   Iterable<String> where(bool f(String element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
 
   List<String> toList() => new List<String>.from(this);
   Set<String> toSet() => new Set<String>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<String> takeWhile(bool test(String value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<String> skipWhile(bool test(String value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   String firstMatching(bool test(String value), { String orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   String lastMatching(bool test(String value), {String orElse()}) {
@@ skipping 1278 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(Transform element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(Transform element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(Transform element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(Transform element)) => map(f);
 
   Iterable<Transform> where(bool f(Transform element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
 
   List<Transform> toList() => new List<Transform>.from(this);
   Set<Transform> toSet() => new Set<Transform>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<Transform> takeWhile(bool test(Transform value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Transform> skipWhile(bool test(Transform value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   Transform firstMatching(bool test(Transform value), { Transform orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   Transform lastMatching(bool test(Transform value), {Transform orElse()}) {
@@ skipping 552 matching lines @@
     return IterableMixinWorkaround.reduce(this, initialValue, combine);
   }
 
   bool contains(ElementInstance element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
-  List mappedBy(f(ElementInstance element)) => IterableMixinWorkaround.mappedByList(this, f);
+  Iterable map(f(ElementInstance element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
+  Iterable mappedBy(f(ElementInstance element)) => map(f);
 
   Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
       IterableMixinWorkaround.where(this, f);
 
   bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
 
   List<ElementInstance> toList() => new List<ElementInstance>.from(this);
   Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  Iterable<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this, n);
 
   Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
-  List<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  Iterable<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   ElementInstance firstMatching(bool test(ElementInstance value), { ElementInstance orElse() }) {
     return IterableMixinWorkaround.firstMatching(this, test, orElse);
   }
 
   ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstance orElse()}) {
@@ skipping 112 matching lines @@
   List<ElementInstance> getRange(int start, int rangeLength) =>
       Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
 
   // -- end List<ElementInstance> mixins.
 
   @DomName('SVGElementInstanceList.item')
   @DocsEditable
   ElementInstance item(int index) native "SVGElementInstanceList_item_Callback";
 
 }