anchor.diff:              | result ->
                   result
   
  +    //
  +    static member First (listSet : ListSet<'T>) : 'T =
  +        match listSet with
  +        | Tail x
  +        | Element (_, x) ->
  +            x
  +
  +    //
  +    static member Last (listSet : ListSet<'T>) : 'T =
  +        match listSet with
  +        | Tail x -> x
  +        | Element (listSet, _) ->
  +            ListSet.Last listSet
  +
  +    //
  +    static member UnionImpl (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>, acc) : ListSet<'T> =
  +        notImpl "ListSet.UnionImpl"
  +
  +    //
  +    static member Union (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>) : ListSet<'T> =
  +        notImpl "ListSet.Union"
  +
  +    //
  +    static member IntersectImpl (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>, acc) : ListSet<'T> option =
  +        notImpl "ListSet.IntersectImpl"
  +
  +    //
  +    static member Intersect (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>) : ListSet<'T> option =
  +        notImpl "ListSet.Intersect"
  +
  +    //
  +    static member DifferenceImpl (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>, acc) : ListSet<'T> option =
  +        notImpl "ListSet.DifferenceImpl"
  +
  +    //
  +    static member Difference (listSet1 : ListSet<'T>, listSet2 : ListSet<'T>) : ListSet<'T> option =
  +        notImpl "ListSet.Difference"
  +
   
   (* OPTIMIZE :   Some of the functional-style operations on PatriciaHashSet use direct non-tail-recursion;
                   performance may be improved if we modify these to use CPS instead. *)
  
positive.code:             else s
          | Empty, _ ->
              Empty
  *)
  (*
      /// <c>IsSubmapOfBy f t1 t2</c> returns <c>true</c> if all keys in t1 are in t2,
      /// and when 'f' returns <c>true</c> when applied to their respective values.
  
negative.code:             else
                  PatriciaHashSet.Join (valueHash, Lf (valueHash, Tail value), p, set)
  
      //
      static member AddSet (valueHash, listSet : ListSet<'T>, set) : PatriciaHashSet<'T> =
          notImpl "PatriciaHashSet.AddSet"
  
      //
      static member RemoveSet (valueHash, set) : PatriciaHashSet<'T> =
          notImpl "PatriciaHashSet.RemoveSet"
  
      /// Computes the union of two PatriciaHashSets.
      static member Union (s, t) : PatriciaHashSet<'T> =
          match s, t with
  