anchor.diff:  ///
   /// All members of this class are thread-safe and may be used concurrently from multiple threads.</remarks>
   [<StructuredFormatDisplay("{AsString}")>]
  -type PersistentHashSet<'a> = internal PersistentHashSet of Map<int, list<'a>> with
  +type PersistentHashSet<'a>(count : int, content : Map<int, list<'a>>) =
  +
  +    member x.Count = count
  +
  +    member internal x.Content = content
  +
       member x.AsString = 
  -        let (PersistentHashSet x) = x
  -        let l = x |> Map.toList |> List.collect (fun (_,v) -> v)
  +        let l = content |> Map.toList |> List.collect (fun (_,v) -> v)
           sprintf "set %A" l
  +
  +    interface System.Collections.IEnumerable with
  +        member x.GetEnumerator() = 
  +            new PersistentHashSetEnumerator<'a>(content) :> _
  +
  +    interface System.Collections.Generic.IEnumerable<'a> with
  +        member x.GetEnumerator() = 
  +            new PersistentHashSetEnumerator<'a>(content) :> _
  +
          
  +and private PersistentHashSetEnumerator<'a>(set : Map<int, list<'a>>) =
  +    let e = (set :> seq<_>).GetEnumerator()
  +    let mutable current = []
  +    let mutable value = Unchecked.defaultof<'a>
  +
  +    member x.MoveNext() =
  +        match current with
  +            | [] -> 
  +                if e.MoveNext() then
  +                    current <- e.Current.Value
  +                    match current with
  +                        | h :: rest ->
  +                            value <- h
  +                            current <- rest
  +                            true
  +                        | [] ->
  +                            Log.warn "[PersistentHashSet] empty bucket"
  +                            x.MoveNext()
  +                else
  +                    false
  +            | h :: rest ->
  +                value <- h 
  +                current <- rest
  +                true
  +
  +    member x.Current = value
  +
  +    member x.Reset() =
  +        e.Reset()
  +        current <- []
  +        value <- Unchecked.defaultof<'a>
  +
  +    member x.Dispose() =
  +        e.Dispose()
  +        current <- []
  +        value <- Unchecked.defaultof<'a>
  +
  +
  +    interface System.Collections.IEnumerator with
  +        member x.MoveNext() = x.MoveNext()
  +        member x.Current = x.Current :> obj
  +        member x.Reset() = x.Reset()
  +
  +    interface System.Collections.Generic.IEnumerator<'a> with
  +        member x.Current = x.Current
  +        member x.Dispose() = x.Dispose()
  +
  +
          
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   [<RequireQualifiedAccess>]
   /// <summary>Functional programming operators related to the <c>PersistentHashSet&lt;_&gt;</c> type.</summary> 
   module PersistentHashSet =
       let inline private (!) (h : PersistentHashSet<'a>) =
  -        let (PersistentHashSet m) = h
  -        m
  +        h.Content
   
       type private EmptyImpl<'a>() =
  -        static let instance : PersistentHashSet<'a> = PersistentHashSet Map.empty
  +        static let instance : PersistentHashSet<'a> = PersistentHashSet(0, Map.empty)
           static member Instance = instance
   
       /// <summary>The empty set for the type 'T.</summary>
  
positive.code:         let mutable l = !set1
          let r = !set2
  
          for (h,vs) in r |> Map.toSeq do
              match Map.tryFind h l with
                  | Some values ->
  
negative.code:     /// <returns>An ordered list of the elements of <c>set</c>.</returns>
      [<CompiledName("ToList")>]
      let toList (set : PersistentHashSet<'a>) =
          set |> Seq.toList
    
      /// <summary>Returns an ordered view of the collection as an enumerable object.</summary>
      /// <param name="set">The input set.</param>
      /// <returns>An ordered sequence of the elements of <c>set</c>.</returns>
      [<CompiledName("ToSeq")>]
      let toSeq (set : PersistentHashSet<'a>) =
          set :> seq<_>    
  
      /// <summary>Builds an array that contains the elements of the set in order.</summary>
      /// <param name="set">The input set.</param>
  