change param name to match docs

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 374 matching lines @@
    * Returns a lazy iterable of the [count] first elements of this iterable.
    *
    * The returned `Iterable` may contain fewer than `count` elements, if `this`
    * contains fewer than `count` elements.
    *
    * The elements can be computed by stepping through [iterator] until [count]
    * elements have been seen.
    *
    * The `count` must not be negative.
    */
-  Iterable<E> take(int n) {
-    return new TakeIterable<E>(this, n);
+  Iterable<E> take(int count) {
+    return new TakeIterable<E>(this, count);
   }
 
   /**
    * Returns a lazy iterable of the leading elements satisfying [test].
    *
    * The filtering happens lazily. Every new iterator of the returned
    * iterable starts iterating over the elements of `this`.
    *
    * The elements can be computed by stepping through [iterator] until an
    * element is found where `test(element)` is false. At that point,
    * the returned iterable stops (its `moveNext()` returns false).
    */
   Iterable<E> takeWhile(bool test(E value)) {
     return new TakeWhileIterable<E>(this, test);
   }
 
   /**
    * Returns an Iterable that provides all but the first [count] elements.
    *
    * When the returned iterable is iterated, it starts iterating over `this`,
    * first skipping past the initial [count] elements.
    * If `this` has fewer than `count` elements, then the resulting Iterable is
    * empty.
    * After that, the remaining elements are iterated in the same order as
    * in this iterable.
    *
    * The `count` must not be negative.
    */
   Iterable<E> skip(int n) {

[Lasse Reichstein Nielsen, 2015/08/11 06:07:00]

This one too.

[sethladd, 2015/08/11 14:48:12]

Done.

     return new SkipIterable<E>(this, n);
   }
 
   /**
    * Returns an Iterable that skips leading elements while [test] is satisfied.
    *
    * The filtering happens lazily. Every new Iterator of the returned
    * Iterable iterates over all elements of `this`.
    *
    * The returned iterable provides elements by iterating this iterable,
@@ skipping 229 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();
 }