anchor.diff:      /// <returns>The number of elements in the set.</returns>
       [<CompiledName("Count")>]
       let count (set : PersistentHashSet<'a>) =
  -        set |> toSeq |> Seq.length
  +        set.Count
   
       /// <summary>Evaluates to "true" if all elements of the first set are in the second</summary>
       /// <param name="set1">The potential subset.</param>
  
positive.code:                 if l |> List.exists (fun e -> e = value) then
                      set
                  else
                      Map.add hash (value::l) map |> PersistentHashSet
              | None ->
                  Map.add hash [value] map |> PersistentHashSet
  
  
      /// <summary>Returns a new set with the given element removed. No exception is raised if 
  
negative.code: ///
  /// All members of this class are thread-safe and may be used concurrently from multiple threads.</remarks>
  [<StructuredFormatDisplay("{AsString}")>]
  type PersistentHashSet<'a>(count : int, content : Map<int, list<'a>>) =
  
      member x.Count = count
  
      member internal x.Content = content
  
      member x.AsString = 
          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>) =
          h.Content
  
      type private EmptyImpl<'a>() =
          static let instance : PersistentHashSet<'a> = PersistentHashSet(0, Map.empty)
          static member Instance = instance
  
      /// <summary>The empty set for the type 'T.</summary>
  