anchor.diff:    Iterable<V> get values => _source.values;
   
   
  +  /**
  +   * Throws an [UnsupportedError];
  +   * operations that change the map are disallowed.
  +   */
     void operator []=(K key, V value) => _throw();
   
  +  /**
  +   * Throws an [UnsupportedError];
  +   * operations that change the map are disallowed.
  +   */
     V putIfAbsent(K key, V ifAbsent()) { _throw(); }
   
  +  /**
  +   * Throws an [UnsupportedError];
  +   * operations that change the map are disallowed.
  +   */
     void addAll(Map<K, V> other) => _throw();
   
  +  /**
  +   * Throws an [UnsupportedError];
  +   * operations that change the map are disallowed.
  +   */
     V remove(K key) { _throw(); }
   
  +  /**
  +   * Throws an [UnsupportedError];
  +   * operations that change the map are disallowed.
  +   */
     void clear() => _throw();
   }
   
  
positive.code: // BSD-style license that can be found in the LICENSE file.
  
  /**
   * Unmodifiable wrappers for [List], [Set] and [Map] objects.
   *
   * The wrappers allow reading from the source list, but writing is prohibited.
   *
   * A non-growable list wrapper allows writing as well, but not changing the
   * list's length.
   */
  library unmodifiable_collection;
  
  export "dart:collection" show UnmodifiableListView;
  
  /**
   * A [List] wrapper that acts as a non-growable list.
   *
   * Writes to the list are written through to the source list, but operations
   * that change the length is not allowed.
   */
  class NonGrowableListView<E> extends _IterableView<E>
                                       implements List<E> {
  
negative.code:   }
  
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void set length(int newLength) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void add(E value) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void addAll(Iterable<E> iterable) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void insert(int index, E element) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void insertAll(int index, Iterable<E> iterable) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    bool remove(Object value) { _throw(); }
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    E removeAt(int index) { _throw(); }
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    E removeLast() { _throw(); }
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void removeWhere(bool test(E element)) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void retainWhere(bool test(E element)) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void removeRange(int start, int end) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void replaceRange(int start, int end, Iterable<E> iterable) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the length of the list are disallowed.
     */
    void clear() => _throw();
  }
  
  /**
   * An unmodifiable set.
   *
   * An UnmodifiableSetView contains a [Set] object and ensures 
   * that it does not change.
   * Methods that would change the set,
   * such as [add] and [remove], throw an [UnsupportedError].
   * Permitted operations defer to the wrapped set.
   */
  class UnmodifiableSetView<E> extends _IterableView<E>
                                        implements Set<E> {
  