anchor.diff:          member x.GetReader() = a.GetReader()
   
   
  +module PSet=
  +    
  +    type PSetChange<'a>(pset : pset<'a>, deltas : list<Delta<'a>>) =
  +        member x.Deltas = deltas
  +        interface Op with
  +            member x.Data = pset.Value |> PersistentHashSet.toSeq |> Seq.map (fun p -> p :> obj)
  +            member x.Target = pset :> IRef
  +            member x.Run() =
  +                pset.CSet |> CSet.applyDeltas deltas
  +                let invert = function Add v -> Rem v | Rem v -> Add v
  +                PSetChange(pset, deltas |> List.map invert) :> Op
  +
  +            member x.TryMergeParallel o =
  +                match o with
  +                    | :? PSetChange<'a> as o ->
  +                        PSetChange(pset, o.Deltas @ deltas) :> Op |> Some
  +                    | _ -> 
  +                        failwith "impossible"
  +
  +            member x.MergeSequential o =
  +                match o with
  +                    | :? PSetChange<'a> as o -> 
  +                        PSetChange(pset, o.Deltas @ deltas) :> Op
  +                    | _ ->
  +                        failwith "impossible"
  +
  +            member x.Serialize (store : obj -> string) =
  +                failwith ""
  +                Map.ofList [
  +                    "Value",        store (pset.CSet |> CSet.toList :> obj)
  +                ]
  +
  +        static member Deserialize (target : pset<'a>, data : Map<string, string>, load : string -> obj) =
  +            failwith ""
  +            let value = data.["Value"] |> load |> unbox<list<'a>>
  +            PSetChange(target, value |> List.map Delta.Add)
  +
  +
  +    let add (m : pset<'a>) (value : 'a) =
  +        Change.single (PSetChange(m, [Add value]) :> Op)
  +
  +    let remove (m : pset<'a>) (value : 'a) =
  +        Change.single (PSetChange(m, [Rem value]) :> Op)
   
   
   [<CustomEquality; CustomComparison>]
  
positive.code: 
          printfn "%A" (a |> Mod.force)
  
      let run() =
          build2()
          read2()
  //
  
negative.code: 
      let pset (name : string) (w : WorkingCopy) =
          w.Refs.GetOrCreate(name, fun name ->
              pset<'a>(name, PersistentHashSet.empty) :> IRef
          ) |> unbox<pset<'a>>
  
  
  