anchor.diff:  // 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.
  + * Wrappers that prevent List, Set, or Map objects from being modified.
  + *
  + * The [Set] and [Map] wrappers allow reading from the wrapped collection,
  + * but prohibit writing.
  + *
  + * The [List] wrapper prevents changes to the length of the wrapped list,
  + * but allows changes to the contents.
    */
   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.
  + * A fixed-length list.
  + *
  + * A NonGrowableListView contains a [List] object and ensures that
  + * its length does not change.
  + * Methods that would change the length of the list,
  + * such as [add] and [remove], throw an [UnsupportedError].
  + *
  + * This class _does_ allow changes to the contents of the wrapped list.
  + * You can, for example, [sort] the list.
  + * Permitted operations defer to the wrapped list.
    */
   class NonGrowableListView<E> extends _IterableView<E>
                                        implements List<E> {
  
positive.code:   Set<E> difference(Set<E> other) => _source.difference(other);
  
  
    void add(E value) => _throw();
  
    void addAll(Iterable<E> elements) => _throw();
  
    bool remove(Object value) { _throw(); }
  
    void removeAll(Iterable elements) => _throw();
  
    void retainAll(Iterable elements) => _throw();
  
    void removeWhere(bool test(E element)) => _throw();
  
    void retainWhere(bool test(E element)) => _throw();
  
    void clear() => _throw();
  }
  
  /**
   * A [Map] wrapper that acts as an unmodifiable map.
   */
  class UnmodifiableMapView<K, V> implements Map<K, V> {
    Map<K, V> _source;
  
negative.code:   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();
  }
  
  