anchor.diff:  
     dynamic get first {
       if (length > 0) return this[0];
  -    throw new StateError("No elements");
  +    throw IterableElementError.noElement();
     }
   
     dynamic get last {
       if (length > 0) return this[length - 1];
  -    throw new StateError("No elements");
  +    throw IterableElementError.noElement();
     }
   
     dynamic get single {
       if (length == 1) return this[0];
  -    if (length == 0) throw new StateError("No elements");
  -    throw new StateError("More than one element");
  +    if (length == 0) throw IterableElementError.noElement();
  +    throw IterableElementError.tooMany();
     }
   
     void removeRange(int start, int end) {
  
positive.code:         // an intermediate structure.
          // TODO(srdjan): Optimize to skip copying if the range does not overlap.
          final temp_buffer = new List(count);
          for (int i = 0; i < count; i++) {
            temp_buffer[i] = from[skipCount + i];
          }
          for (int i = start; i < end; i++) {
            this[i] = temp_buffer[i - start];
          }
          return;
        }
      }
      IterableMixinWorkaround.setRangeList(this, start,
                                           end, from, skipCount);
    }
  
    void setAll(int index, Iterable iterable) {
  
negative.code:   }
  
    String join([String separator = ""]) {
      StringBuffer buffer = new StringBuffer();
      buffer.writeAll(this, separator);
      return buffer.toString();
    }
  
    dynamic reduce(dynamic combine(value, element)) {
      var len = this.length;
      if (len == 0) throw IterableElementError.noElement();
      var i = 0;
      var value = this[0];
      for (var i = 1; i < len; ++i) {
        value = combine(value, this[i]);
      }
      return value;
    }
  
    dynamic fold(dynamic initialValue,
                 dynamic combine(dynamic initialValue, element)) {
      var len = this.length;
      for (var i = 0; i < len; ++i) {
        initialValue = combine(initialValue, this[i]);
      }
      return initialValue;
    }
  
    Iterable map(f(element)) => new MappedIterable(this, f);
  
    Iterable expand(Iterable f(element)) => new ExpandIterable(this, f);
  
    bool every(bool f(element)) {
      var len = this.length;
      for (var i = 0; i < len; ++i) {
        if (!f(this[i])) return false;
      }
      return true;
    }
  
    bool any(bool f(element)) {
      var len = this.length;
      for (var i = 0; i < len; ++i) {
        if (f(this[i])) return true;
      }
      return false;
    }
  
    dynamic firstWhere(bool test(element), {orElse()}) {
      var len = this.length;
      for (var i = 0; i < len; ++i) {
        var element = this[i];
        if (test(element)) return element;
      }
      if (orElse != null) return orElse();
      throw IterableElementError.noElement();
    }
  
    dynamic lastWhere(bool test(element), {orElse()}) {
      var result = null;
      var len = this.length;
      for (var i = len - 1; i >= 0; --i) {
        var element = this[i];
        if (test(element)) {
          return element;
        }
      }
      if (orElse != null) return orElse();
      throw IterableElementError.noElement();
    }
  
    dynamic singleWhere(bool test(element)) {
      var result = null;
      bool foundMatching = false;
      var len = this.length;
      for (var i = 0; i < len; ++i) {
        var element = this[i];
        if (test(element)) {
          if (foundMatching) {
            throw IterableElementError.tooMany();
          }
          result = element;
          foundMatching = true;
        }
      }
      if (foundMatching) return result;
      throw IterableElementError.noElement();
    }
  
    dynamic elementAt(int index) {
  