anchor.diff:      extends IterableBase<E>
       implements ReadSet<E> {
   
  -  ReadSet<E> operator +(ReadSet<E> persistentSet) =>
  -      union(persistentSet);
  +  ReadSet<E> operator +(ReadSet<E> other) =>
  +      union(other);
   
  -  ReadSet<E> operator -(ReadSet<E> persistentSet) =>
  -      difference(persistentSet);
  +  ReadSet<E> operator -(ReadSet<E> other) =>
  +      difference(other);
   
  -  ReadSet<Pair> operator *(ReadSet persistentSet) =>
  -      cartesianProduct(persistentSet);
  +  ReadSet<Pair> operator *(ReadSet other) =>
  +      cartesianProduct(other);
   
     ReadSet strictMap(f(E element)) =>
         new PersistentSet.from(this.map(f));
  
positive.code:   /// A strict (non-lazy) version of [where].
    ReadSet<E> strictWhere(bool f(E element));
    
    PersistentSet<E> asPersistent();
    
    TransientSet<E> asTransient();
  }
  
  abstract class PersistentSet<E> implements ReadSet<E> {
  
    /// Creates an empty [PersistentSet] using its default implementation.
  
negative.code: 
  part of persistent;
  
  /**
   * A read-only set, unordered collection of distinct elements of type [E].
   *
   * There is no default implementation of [ReadVector], since it just
   * specifies the common interface of [PersistentVector] and [TransientVector].
   */
  abstract class ReadSet<E> implements Iterable<E> {
    
    /**
     * Returns a new set of all the elements that are included
     * in either `this` or [other]
     */
    ReadSet<E> union(ReadSet<E> other);
  
    /// Alias for [union].
    ReadSet<E> operator +(ReadSet<E> other);
  
    /**
     * Returns a new set of all the elements that are included in `this` but
     * not in [other]
     */
    ReadSet<E> difference(ReadSet<E> other);
  
    /// Alias for [difference].
    ReadSet<E> operator -(ReadSet<E> other);
  
    /**
     * Returns a new set of all the pairs `Pair<first, second>` such that
     * `first` is included in `this` and
     * `second` is included in [other]
     */
    ReadSet<Pair<E,dynamic>> cartesianProduct(ReadSet other);
  
    /// Alias for [cartesianProduct].
    ReadSet<Pair<E,dynamic>> operator *(ReadSet other);
  
    /**
     * Returns a new set of all the elements that are included
     * in both `this` and [other]
     */
    ReadSet<E> intersection(ReadSet<E> other);
  
    /// Randomly picks an element of [this].
    E pickRandomElement([Random random]);
  