Add setAll, insertAll, replaceRange and fillRange.

sdk/lib/core/list.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 dart.core;
 
 /**
  * A [List] is an indexable collection with a length.
  *
  * A `List` implementation can choose not to support all methods
@@ skipping 171 matching lines @@
    *
    * This increases the length of the list by one and shifts all later elements
    * towards the end of the list.
    *
    * It is an error if the [index] does not point inside the list or at the
    * position after the last element.
    */
   void insert(int index, E element);
 
   /**
+   * Inserts all elements of [iterable] at position [index] in the list.
+   *
+   * This increases the length of the list by the length of [iterable] and
+   * shifts all later elements towards the end of the list.
+   *
+   * It is an error if the [index] does not point inside the list or at the
+   * position after the last element.
+   */
+  void insertAll(int index, Iterable<E> iterable);
+
+  /**
+   * Overwrites elements of `this` with the elemenst of [iterable] starting
+   * at position [index] in the list.
+   *
+   * This operation does not increase the length of the list.
+   *
+   * It is an error if the [index] does not point inside the list or at the
+   * position after the last element.
+   *
+   * It is an error if the [iterable] is longer than [length] - [index].

[Lasse Reichstein Nielsen, 2013/04/15 12:03:08]

How about not making it an error if the iterable is longer, and just truncate.

The behavior is useful in any case, and I don't want users catching the error to
get the useful functionality.

Perhaps you could return a boolean that is true if the iterable was longer
(i.e., if it got truncated by writing).
It's probably not a good idea (boolean returns in collections tend to mean "did
the collection change").

[floitsch, 2013/04/15 16:22:48]

Both are reasonable. I prefer the error since that gives you an error when you
write list.setAll(5, otherList.getRange(4, 7)).

+   */
+  void setAll(int index, Iterable<E> iterable);
+
+  /**
    * Removes [value] from the list. Returns true if [value] was
    * in the list. Returns false otherwise. The method has no effect
    * if [value] value was not in the list.
    */
   bool remove(Object value);
 
   /**
    * Removes the element at position [index] from the list.
    *
    * This reduces the length of the list by one and moves all later elements
@@ skipping 77 matching lines @@
 
   /**
    * Removes the elements in the range [start]..[end] (excluding).
    *
    * It is an error if [start]..[end] is not a valid range pointing into the
    * `this`.
    */
   void removeRange(int start, int end);
 
   /**
+   * Sets the elements in the range [start]..[end] (excluding) to the given
+   * [fillValue].
+   *
+   * It is an error if [start]..[end] is not a valid range pointing into the
+   * `this`.
+   */
+  void fillRange(int start, int end, [E fillValue]);
+
+  /**
+   * Removes the elements in the range [start]..[end] (excluding) and replaces
+   * them with the contents of the [iterable].
+   *
+   * It is an error if [start]..[end] is not a valid range pointing into the
+   * `this`.
+   *
+   * Example:
+   *
+   *     var list = [1, 2, 3, 4, 5];
+   *     list.replaceRange(1, 3, [6, 7, 8, 9]);
+   *     print(list);  // [1, 6, 7, 8, 9, 4, 5]
+   */
+  void replaceRange(int start, int end, Iterable<E> iterable);
+
+  /**
    * Returns an unmodifiable [Map] view of `this`.
    *
    * It has the indices of this list as keys, and the corresponding elements
    * as values.
    */
   Map<int, E> asMap();
 }