anchor.diff:  
   /// Module used to create and manage dependencies
   module Dependencies =
  +
       /// Create a dependency manager
       let create (dependsOn : ITracksDependents array) source = 
           let deps =
               dependsOn
               |> Array.map (fun t -> WeakReference<_>(t))
           DependencyTracker<_>(deps) :> IDependencyManager<_>
  +
       /// Create a dependency manager for a source object which stores dependency information outside of the object's memory space.  
       let createRemote source =
           { new IDependencyManager<'a> with
               member __.Add (dep: IDependent, source: ISignal<'a>) : unit = SignalManager.AddDependency(source, dep)
  +
               member __.Subscribe (obs: IObserver<'a> , source: ISignal<'a>) : IDisposable = SignalManager.Subscribe(source, obs)
   
               member __.Remove (dep: IDependent, source: ISignal<'a>) = SignalManager.RemoveDependency(source, dep)
  +
               member __.RemoveAll (source: ISignal<'a>) = SignalManager.RemoveAllDependencies source
   
               member __.HasDependencies with get() = SignalManager.IsTracked source
  
positive.code:                 |> Array.exists (fun wr -> WeakRef.contains dep wr)
              if (not depExists) then
                  depIDeps <- depIDeps |> Array.append [| WeakReference<_>(dep) |])
      member this.AddObserver (obs,source) =
          lock this.LockObj (fun _ ->
              depObservers <- depObservers |> Array.append [| obs |])
  
negative.code:         lock dependencies (fun _ -> 
              let dep = dependencies.GetValue(source, createValueCallbackFor source) :?> DependencyTracker<'a>
              dep.Add(target, source))
  
      static member internal Subscribe (source : ISignal<'a>, target : IObserver<'a>) =
          lock dependencies (fun _ -> 
              let dep = dependencies.GetValue(source, createValueCallbackFor source) :?> DependencyTracker<'a>
  