anchor.diff:      member x.Update(keys : pset<'k>) =
           let deltas =
               lock content (fun () -> 
  -                let removed = HashSet store.Values
  +                let removed = HashSet content
                   let added = HashSet()
                   for k in PSet.toSeq keys do
                       let id = Unique.id k
  -
  -                    match store.TryGetValue id with
  -                        | (true, v) -> 
  -                            update(v, k)
  -                            removed.Remove v |> ignore
  -                        | _ ->
  -                            let v = create k
  -                            store.Add(id, v)
  -                            added.Add v |> ignore
  +                    let v = cache.GetOrCreate(k, create)
  +                    if not (removed.Remove v) then 
  +                        added.Add v |> ignore
   
                   [
                       yield! added |> Seq.filter content.Add |> Seq.map Add
  
positive.code: 
          member x.Copy = x :> aset<_>
          member x.GetReader() = x.GetReader()
  
negative.code:         current <- keys
          x.ApplyDeltas(delta)
  
  type IReuseCache =
      interface end
  
  type ReuseCache<'a>() =
      let store = ConditionalWeakTable<Id, ref<'a>>()
      
      interface IReuseCache
  
      member x.GetOrCreate(k : 'k, f : 'k -> 'a) =
          let i = Unique.id k
          lock store (fun () ->
              match store.TryGetValue i with
                  | (true, v) -> !v
                  | _ -> 
                      let v = f k
                      store.Add(i, ref v)
                      v
          )
          
  
  type MapSet<'k, 'v when 'k : equality and 'k :> IUnique>(cache : ReuseCache<'v>, initial : pset<'k>, create : 'k -> 'v, update : 'v * 'k -> unit) =
      //let store = Dictionary<int64, 'v>()
      let readers = HashSet<ASetReaders.EmitReader<'v>>()
      let content = VersionedSet (HashSet())
      let readers = WeakSet<ASetReaders.EmitReader<'v>>()
      do for e in initial do
          let id = Unique.id e
          let mutable isNew = false
          let v = cache.GetOrCreate(e, fun k -> isNew <- true; create k)
          if not (content.Add v) then
              update(v,e)
  
      let emit (deltas : Option<Change<'v>>) =
          lock readers (fun () ->
  