anchor.diff:    }
   
   
  +  /**
  +   * 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();
   }
   
   /**
  - * A [Set] wrapper that acts as an unmodifiable set.
  + * 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> {
  
positive.code:   Iterable<V> get values => _source.values;
  
  
    void operator []=(K key, V value) => _throw();
  
    V putIfAbsent(K key, V ifAbsent()) { _throw(); }
  
    void addAll(Map<K, V> other) => _throw();
  
    V remove(K key) { _throw(); }
  
    void clear() => _throw();
  }
  
  
negative.code:   Set<E> difference(Set<E> other) => _source.difference(other);
  
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void add(E value) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void addAll(Iterable<E> elements) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    bool remove(Object value) { _throw(); }
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void removeAll(Iterable elements) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void retainAll(Iterable elements) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void removeWhere(bool test(E element)) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void retainWhere(bool test(E element)) => _throw();
  
    /**
     * Throws an [UnsupportedError];
     * operations that change the set are disallowed.
     */
    void clear() => _throw();
  }
  
  /**
   * An unmodifiable map.
   *
   * An UnmodifiableMapView contains a [Map] object and ensures 
   * that it does not change.
   * Methods that would change the map,
   * such as [addAll] and [remove], throw an [UnsupportedError].
   * Permitted operations defer to the wrapped map.
   */
  class UnmodifiableMapView<K, V> implements Map<K, V> {
    Map<K, V> _source;
  