anchor.diff:      [<CompiledName("Singleton")>]
       let singleton (value : 'a) = 
           let hash = value.GetHashCode()
  -        [hash, [value]] |> Map.ofList |> PersistentHashSet
  +        PersistentHashSet(1, [hash, [value]] |> Map.ofList)
   
       /// <summary>Returns a new set with an element added to the set. No exception is raised if
       /// the set already contains the given element.</summary>
  
positive.code: ///
  /// 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
      member x.AsString = 
          let (PersistentHashSet x) = x
          let l = x |> Map.toList |> List.collect (fun (_,v) -> v)
          sprintf "set %A" l
         
         
  [<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
  
      type private EmptyImpl<'a>() =
          static let instance : PersistentHashSet<'a> = PersistentHashSet Map.empty
          static member Instance = instance
  
      /// <summary>The empty set for the type 'T.</summary>
  
negative.code:         let mutable l = !set1
          let r = !set2
  
          let mutable count = set1.Count
          for (h,vs) in r |> Map.toSeq do
              match Map.tryFind h l with
                  | None -> ()
                  | Some values ->
                      let newValues = values |> List.filter (fun v -> vs |> List.exists (fun vi -> vi = v))
                      l <- Map.add h newValues l
                      count <- count + (List.length newValues - List.length values)
          
          PersistentHashSet(count, l)
     
     
      /// <summary>Computes the intersection of a sequence of sets. The sequence must be non-empty.</summary>
  