Change new List(n) to return fixed length list.

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. It can be of
- * fixed size or extendable.
+ * A [List] is an indexable collection with a length.
+ *
+ * A `List` implementation can be choose not to support all methods
+ * of the `List` interface.
+ *
+ * The most common list types are:
+ * * Fixed length list. Does not support operations that changes length.
+ * * Growable list. Full implmentation of the interface.

[floitsch, 2013/02/26 13:54:19]

implementation

[Lasse Reichstein Nielsen, 2013/02/26 15:26:00]

Done.

+ * * Unmodifiable list. A list where you can't change length or values.

[floitsch, 2013/02/26 13:54:19]

... list. Changing the length or values yields an exception. If an unmodifiable
list is backed by a mutable structure reading the values can yield different
results over time, though.

Example:

    var fixedLengthList = new List(5);
    fixedLengthList.length = 0;  // throws.
    fixedLengthList.add(499);  // throws
    var growableList = [1, 2];
    var unmodifiableList = growableList.reversed;
    unmodifiableList[0] = 5;  // throws.
    unmodifiableList.length = 0;  // throws.
    reversed[0];  // 2.
    growableList.add(499);
    reversed[0];  // 499.

[Lasse Reichstein Nielsen, 2013/02/26 15:26:00]

Example is very long. And reversed doesn't return a List. I don't think we have
an example of a mutable-backed unmodifiable list in the standard library.

"yields an exception" is vague and slightly confusing. I prefer "It is an error
to".

Reworded and example added.

  */
 abstract class List<E> implements Collection<E> {
   /**
    * Creates a list of the given [length].
    *
-   * The length of the returned list is not fixed.
+   * The list is a fixed-length list if [length] is provided, and an empty
+   * growable list if [length] is omitted.
    */
-  external factory List([int length = 0]);
+  external factory List([int length]);
 
   /**
    * Creates a fixed-sized list of the given [length] where each entry is

[floitsch, 2013/02/26 13:54:19]

fixed-length

[Lasse Reichstein Nielsen, 2013/02/26 15:26:00]

Done.

    * filled with [fill].
    */
-  external factory List.fixedLength(int length, {E fill: null});
+  external factory List.filled(int length, E fill);
+
+  /**
+   * *Deprecated*: Use `new List(count)` instead.
+   */
+  factory List.fixedLength(int count) => new List(count);
 
   /**
    * Creates an list with the elements of [other]. The order in
    * the list will be the order provided by the iterator of [other].
    *
    * The length of the returned list is not fixed.
    */
-  factory List.from(Iterable other) {
-    var list = new List<E>();
+  factory List.from(Iterable other, { bool growable: true }) {
+    List<E> list = new List<E>();
     for (E e in other) {
       list.add(e);
     }
-    return list;
+    if (growable) return list;
+    int length = list.length;
+    List<E> fixedList = new List<E>(length);
+    for (int i = 0; i < length; i++) {
+      fixedList[i] = list[i];
+    }
+    return fixedList;
   }
 
   /**
+   * Generate a `List` of elements.
+   *
+   * Generates a list of values, where the values are created by
+   * calling the [generator] function for each index in the range
+   * 0 .. [length] - 1.
+   *
+   * The created length's length is fixed unless [growable] is true.
+   */
+  factory List.generate(int length, E generator(int index),
+                       { bool growable: false }) {
+    List<E> result;
+    if (growable) {
+      result = <E>[]..length = length;
+    } else {
+      result = new List<E>(length);
+    }
+    for (int i = 0; i < length; i++) {
+      result[i] = generator(i);
+    }
+    return result;
+  }
+
+  /**
    * Returns the element at the given [index] in the list or throws
    * an [RangeError] if [index] is out of bounds.
    */
   E operator [](int index);
 
   /**
    * Sets the entry at the given [index] in the list to [value].
    * Throws an [RangeError] if [index] is out of bounds.
    */
   void operator []=(int index, E value);
@@ skipping 130 matching lines @@
    * not extendable.
    * If [length] is 0, this method does not do anything.
    * If [start] is the length of the list, this method inserts the
    * range at the end of the list.
    * Throws an [ArgumentError] if [length] is negative.
    * Throws an [RangeError] if [start] is negative or if
    * [start] is greater than the length of the list.
    */
   void insertRange(int start, int length, [E fill]);
 }