anchor.diff:              !self ()
           )
   
  -        let set = callbackTable.GetOrCreateValue(m)
  -        let s = new CallbackSubscription(m, !self, live, m, set)
  -        set.Add s |> ignore
  +        let callbackSet = callbackTable.GetOrCreateValue(set)
  +        let s = new CallbackSubscription(set, !self, live, m, callbackSet)
  +        callbackSet.Add s |> ignore
           s :> IDisposable
   
  
positive.code:         r.AddOutput res
          res
  
      let reduceM (f : seq<'a> -> 'b) (s : aset<IMod<'a>>) : IMod<'b> =
          s |> toMod |> Mod.bind (Mod.mapN f)
  
      let foldSemiGroupM (add : 'a -> 'a -> 'a) (zero : 'a) (s : aset<IMod<'a>>) : IMod<'a> =
          let r = s.GetReader()
          let sum = ref zero
  
          let res = ref Unchecked.defaultof<_>
          res :=
              Mod.custom (fun () ->
                  let mutable rem = false
                  let delta = r.GetDelta()
                  for d in delta do
                      match d with
                          | Add v -> 
                              v.AddOutput !res
                              sum := add !sum (v.GetValue())
                          | Rem v -> 
                              v.RemoveOutput !res
                              rem <- true
  
                  if rem then
                      sum := r.Content |> Seq.fold (fun s v -> add s (v.GetValue())) zero
  
                  !sum
              )
  
          r.AddOutput !res
          !res
  
      let foldGroupM (add : 'a -> 'a -> 'a) (sub : 'a -> 'a -> 'a) (zero : 'a) (s : aset<IMod<'a>>) : IMod<'a> =
          let r = s.GetReader()
          let sum = ref zero
  
          let res = ref Unchecked.defaultof<_>
          res :=
              Mod.custom (fun () ->
                  let delta = r.GetDelta()
                  for d in delta do
                      match d with
                          | Add v -> 
                              v.AddOutput !res
                              sum := add !sum (v.GetValue())
                          | Rem v -> 
                              v.RemoveOutput !res
                              sum := sub !sum (v.GetValue())
                  !sum
              )
  
          r.AddOutput !res
          !res
  
  
      let inline sum (s : aset<'a>) = foldGroup (+) (-) LanguagePrimitives.GenericZero s
  
negative.code: 
      let collect' (f : 'a -> aset<'b>) (set : seq<'a>) =
          set |> Seq.map f |> concat'
    
      let mapM (f : 'a -> IMod<'b>) (s : aset<'a>) =
          s |> collect (fun v ->
              v |> f |> ofMod
          )
  
      let filterM (f : 'a -> IMod<bool>) (s : aset<'a>) =
          s |> collect (fun v ->
              v |> f |> bind (fun b -> if b then single v else empty)
          )
  
      let chooseM (f : 'a -> IMod<Option<'b>>) (s : aset<'a>) =
          s |> collect (fun v ->
              v |> f |> bind (fun b -> match b with | Some v -> single v | _ -> empty)
          )
  
      let flattenM (s : aset<IMod<'a>>) =
          s |> collect ofMod
  
      let reduce (f : seq<'a> -> 'b) (s : aset<'a>) : IMod<'b> =
          s |> toMod |> Mod.map f
  