Create generic check methods for RangeError causing checks.

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;
 
 /**
  * An object that uses an [Iterator] to serve objects one at a time.
  *
  * You can iterate over all objects served by an Iterable object
@@ skipping 183 matching lines @@
    * Returns true if there is no element in this collection.
    */
   bool get isEmpty;
 
   /**
    * Returns true if there is at least one element in this collection.
    */
   bool get isNotEmpty;
 
   /**
-   * Returns an [Iterable] with at most [n] elements.
+   * Returns an [Iterable] with at most [count] elements.
    *
-   * The returned [Iterable] may contain fewer than [n] elements, if `this`
-   * contains fewer than [n] elements.
+   * The returned `Iterable` may contain fewer than `count` elements, if `this`
+   * contains fewer than `count` elements.
    *
-   * It is an error if [n] is negative.
+   * It is an error if `count` is negative.
    */
-  Iterable<E> take(int n);
+  Iterable<E> take(int count);
 
   /**
    * Returns an Iterable that stops once [test] is not satisfied anymore.
    *
    * The filtering happens lazily. Every new Iterator of the returned
    * Iterable starts iterating over the elements of `this`.
    *
    * When the iterator encounters an element `e` that does not satisfy [test],
    * it discards `e` and moves into the finished state. That is, it does not
    * get or provide any more elements.
    */
   Iterable<E> takeWhile(bool test(E value));
 
   /**
-   * Returns an Iterable that skips the first [n] elements.
+   * Returns an Iterable that skips the first [count] elements.
    *
-   * If `this` has fewer than [n] elements, then the resulting Iterable is
+   * If `this` has fewer than `count` elements, then the resulting Iterable is
    * empty.
    *
-   * It is an error if [n] is negative.
+   * It is an error if `count` is negative.
    */
-  Iterable<E> skip(int n);
+  Iterable<E> skip(int count);
 
   /**
    * Returns an Iterable that skips elements while [test] is satisfied.
    *
    * The filtering happens lazily. Every new Iterator of the returned
    * Iterable iterates over all elements of `this`.
    *
    * As long as the iterator's elements satisfy [test] they are
    * discarded. Once an element does not satisfy the [test] the iterator stops
    * testing and uses every later element unconditionally. That is, the elements
@@ skipping 70 matching lines @@
   _GeneratorIterable(this._end, E generator(int n))
       : _start = 0,
         _generator = (generator != null) ? generator : _id;
 
   _GeneratorIterable.slice(this._start, this._end, this._generator);
 
   Iterator<E> get iterator =>
       new _GeneratorIterator<E>(_start, _end, _generator);
   int get length => _end - _start;
 
-  Iterable<E> skip(int n) {
-    if (n < 0) throw new RangeError.value(n);
-    if (n == 0) return this;
-    int newStart = _start + n;
+  Iterable<E> skip(int count) {
+    RangeError.checkNotNegative(count, "count");
+    if (count == 0) return this;
+    int newStart = _start + count;
     if (newStart >= _end) return new EmptyIterable<E>();
     return new _GeneratorIterable<E>.slice(newStart, _end, _generator);
   }
 
-  Iterable<E> take(int n) {
-    if (n < 0) throw new RangeError.value(n);
-    if (n == 0) return new EmptyIterable<E>();
-    int newEnd = _start + n;
+  Iterable<E> take(int count) {
+    RangeError.checkNotNegative(count, "count");
+    if (count == 0) return new EmptyIterable<E>();
+    int newEnd = _start + count;
     if (newEnd >= _end) return this;
     return new _GeneratorIterable<E>.slice(_start, newEnd, _generator);
   }
 
   static int _id(int n) => n;
 }
 
 class _GeneratorIterator<E> implements Iterator<E> {
   final int _end;
   final _Generator<E> _generator;
@@ skipping 21 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();
 }