anchor.diff:    }
   
     /**
  -   * Returns the element at the given [index] in the list or throws
  -   * an [RangeError] if [index] is out of bounds.
  +   * Returns the object at the given [index] in the list
  +   * or throws a [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.
  +   * Sets the value at the given [index] in the list to [value]
  +   * or throws a [RangeError] if [index] is out of bounds.
      */
     void operator []=(int index, E value);
   
     /**
  -   * Returns the number of elements in the list.
  -   *
  -   * The valid indices for a list are 0 through `length - 1`.
  +   * Returns the number of objects in this list.
  +   *
  +   * The valid indices for a list are `0` through `length - 1`.
      */
     int get length;
   
     /**
  -   * Changes the length of the list. If [newLength] is greater than
  +   * Changes the length of this list.
  +   *
  +   * If [newLength] is greater than
      * the current [length], entries are initialized to [:null:].
      *
  -   * Throws an [UnsupportedError] if the list is not extendable.
  +   * Throws an [UnsupportedError] if the list is fixed-length.
      */
     void set length(int newLength);
   
     /**
  -   * Adds [value] at the end of the list, extending the length by
  -   * one.
  -   *
  -   * Throws an [UnsupportedError] if the list is not extendable.
  +   * Adds [value] to the end of this list,
  +   * extending the length by one.
  +   *
  +   * Throws an [UnsupportedError] if the list is fixed-length.
      */
     void add(E value);
   
     /**
  -   * Appends all elements of the [iterable] to the end of this list.
  -   *
  -   * Extends the length of the list by the number of elements in [iterable].
  -   * Throws an [UnsupportedError] if this list is not extensible.
  +   * Appends all objects of [iterable] to the end of this list.
  +   *
  +   * Extends the length of the list by the number of objects in [iterable].
  +   * Throws an [UnsupportedError] if this list is fixed-length.
      */
     void addAll(Iterable<E> iterable);
   
     /**
  -   * Returns an [Iterable] of the elements of this [List] in reverse order.
  +   * Returns an [Iterable] of the objects in this list in reverse order.
      */
     Iterable<E> get reversed;
   
     /**
  -   * Sorts the list according to the order specified by the [compare] function.
  +   * Sorts this list according to the order specified by the [compare] function.
      *
      * The [compare] function must act as a [Comparator].
      *
  -   * The default [List] implementations use [Comparable.compare] if
  +   * The default List implementations use [Comparable.compare] if
      * [compare] is omitted.
      */
     void sort([int compare(E a, E b)]);
   
     /**
  -   * Returns the first index of [element] in the list.
  +   * Returns the first index of [element] in this list.
      *
      * Searches the list from index [start] to the length of the list.
  -   * The first time an element [:e:] is encountered so that [:e == element:],
  -   * the index of [:e:] is returned.
  +   * The first time an object [:o:] is encountered so that [:o == element:],
  +   * the index of [:o:] is returned.
      * Returns -1 if [element] is not found.
      */
     int indexOf(E element, [int start = 0]);
   
     /**
  -   * Returns the last index of [element] in the list.
  -   *
  -   * Searches the list backwards from index [start] (inclusive) to 0.
  -   *
  -   * The first time an element [:e:] is encountered so that [:e == element:],
  -   * the index of [:e:] is returned.
  -   *
  -   * If start is not provided, it defaults to [:this.length - 1:].
  +   * Returns the last index of [element] in this list.
  +   *
  +   * Searches the list backwards from index [start] to 0.
  +   *
  +   * The first time an object [:o:] is encountered so that [:o == element:],
  +   * the index of [:o:] is returned.
  +   *
  +   * If [start] is not provided, it defaults to [:this.length - 1:].
      *
      * Returns -1 if [element] is not found.
      */
     int lastIndexOf(E element, [int start]);
   
     /**
  -   * Removes all elements in the list.
  -   *
  -   * The length of the list becomes zero.
  -   *
  -   * Throws an [UnsupportedError], and retains all elements, if the
  -   * length of the list cannot be changed.
  +   * Removes all objects from this list;
  +   * the length of the list becomes zero.
  +   *
  +   * Throws an [UnsupportedError], and retains all objects, if this 
  +   * is a fixed-length list.
      */
     void clear();
   
     /**
  -   * Inserts the element at position [index] in the list.
  -   *
  -   * This increases the length of the list by one and shifts all elements
  +   * Inserts the object at position [index] in this list.
  +   *
  +   * This increases the length of the list by one and shifts all objects
      * at or after the index 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.
  +   * An error occurs if the [index] is less than 0 or greater than length.
  +   * An [UnsupportedError] occurs if the list is fixed-length.
      */
     void insert(int index, E element);
   
     /**
  -   * Inserts all elements of [iterable] at position [index] in the list.
  +   * Inserts all objects of [iterable] at position [index] in this 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.
  +   * shifts all later objects towards the end of the list.
  +   *
  +   * An error occurs if the [index] is less than 0 or greater than length.
  +   * An [UnsupportedError] occurs if the list is fixed-length.
      */
     void insertAll(int index, Iterable<E> iterable);
   
     /**
  -   * Overwrites elements of `this` with the elemenst of [iterable] starting
  -   * at position [index] in the list.
  +   * Overwrites objects of `this` with the objects of [iterable], starting
  +   * at position [index] in this list.
      *
      * This operation does not increase the length of `this`.
      *
  -   * 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].
  +   * An error occurs if the [index] is less than 0 or greater than length.
  +   * An error occurs if the [iterable] is longer than [length] - [index].
      */
     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.
  +   * Removes [value] from this list.
  +   *
  +   * Returns true if [value] was in the list.
  +   * Returns false otherwise.
  +   * The method has no effect if [value] was not in the list.
  +   *
  +   * An [UnsupportedError] occurs if the list is fixed-length.
      */
     bool remove(Object value);
   
     /**
  -   * Removes the element at position [index] from the list.
  -   *
  -   * This reduces the length of `this` by one and moves all later elements
  +   * Removes the object at position [index] from this list.
  +   *
  +   * This method reduces the length of `this` by one and moves all later objects
      * down by one position.
      *
  -   * Returns the removed element.
  -   *
  -   * Throws an [ArgumentError] if [index] is not an [int].
  -   *
  -   * Throws an [RangeError] if the [index] does not point inside
  -   * the list.
  -   *
  -   * Throws an [UnsupportedError], and doesn't remove the element,
  -   * if the length of `this` cannot be changed.
  +   * Returns the removed object.
  +   *
  +   * * Throws an [ArgumentError] if [index] is not an [int].
  +   * * Throws a [RangeError] if the [index] is out of range for this list.
  +   * * Throws an [UnsupportedError], and doesn't remove the object,
  +   * if this is a fixed-length list.
      */
     E removeAt(int index);
   
     /**
  -   * Pops and returns the last element of the list.
  -   * Throws a [UnsupportedError] if the length of the
  -   * list cannot be changed.
  +   * Pops and returns the last object in this list.
  +   *
  +   * Throws an [UnsupportedError] if this is a fixed-length list.
      */
     E removeLast();
   
     /**
  -   * Removes all elements of this list that satisfy [test].
  -   *
  -   * An elements [:e:] satisfies [test] if [:test(e):] is true.
  +   * Removes all objects from this list that satisfy [test].
  +   *
  +   * An object [:o:] satisfies [test] if [:test(o):] is true.
  +   *
  +   * Throws an [UnsupportedError] if this is a fixed-length list.
      */
     void removeWhere(bool test(E element));
   
     /**
  -   * Removes all elements of this list that fail to satisfy [test].
  -   *
  -   * An elements [:e:] satisfies [test] if [:test(e):] is true.
  +   * Removes all objects from this list that fail to satisfy [test].
  +   *
  +   * An object [:o:] satisfies [test] if [:test(o):] is true.
  +   *
  +   * Throws an [UnsupportedError] if this is a fixed-length list.
      */
     void retainWhere(bool test(E element));
   
     /**
  -   * Returns a new list containing the elements from [start] to [end].
  -   *
  -   * The result contains elements of this list with indices greater than or
  -   * equal to [start] and less than [end].
  +   * Returns a new list containing the objects
  +   * from [start] inclusive to [end] exclusive.
      *
      * If [end] is omitted, the [length] of `this` is used.
      *
  -   * It is an error if [start] is outside the range `0` .. `[length]` or if
  -   * [end] is outside the range `[start]` .. `[length]`.
  +   * An error occurs if [start] is outside the range `0` .. `length` or if
  +   * [end] is outside the range `start` .. `length`.
      */
     List<E> sublist(int start, [int end]);
   
     /**
  -   * Returns an [Iterable] that iterates over the elements in the range
  -   * [start] to [end] exclusive. The result of this function
  -   * is backed by `this`.
  -   *
  -   * It is an error if [end] is before [start].
  -   *
  -   * It is an error if the [start] and [end] are not valid ranges at the time
  -   * of the call to this method. The returned [Iterable] behaves similar to
  -   * `skip(start).take(end - start)`. That is, it will not throw exceptions
  +   * Returns an [Iterable] that iterates over the objects in the range
  +   * [start] inclusive to [end] exclusive.
  +   *
  +   * An error occurs if [end] is before [start].
  +   *
  +   * An error occurs if the [start] and [end] are not valid ranges at the time
  +   * of the call to this method. The returned [Iterable] behaves like
  +   * `skip(start).take(end - start)`. That is, it does not throw exceptions
      * if `this` changes size.
      *
      * Example:
  
positive.code:   }
  
    /**
     * Generate a `List` of values.
     *
     * Creates a list with [length] positions
     * and fills them by values created by calling [generator]
     * for each index in the range `0` .. `[length] - 1`
     * in increasing order.
     *
     * The created list's length is fixed unless [growable] is true.
     */
    factory List.generate(int length, E generator(int index),
                         { bool growable: true }) {
  
negative.code:   Iterable<E> getRange(int start, int end);
  
    /**
     * Copies the objects of [iterable], skipping [skipCount] objects first,
     * into the range [start] inclusive to [end] exclusive of `this`.
     *
     * If [start] equals [end] and [start]..[end] represents a legal range, this
     * method has no effect.
     *
     * An error occurs if [start]..[end] is not a valid range for `this`.
     * An error occurs if the [iterable] does not have enough objects after
     * skipping [skipCount] objects.
     *
     * Example:
     *
  