anchor.diff:          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>
  
positive.code:     // We want this as lightweight as possible,
      // so we do our own management as needed
      let mutable depIDeps : WeakReference<IDependent> array = [| |]
      // Note that observers can't be weak referenced, as Observable.add needs to persist
      let mutable depObservers : IObserver<'a> array = [| |]
          
      // These are ugly, as it purposefully creates side effects
      // It returns true if we signaled and the object is alive,
      // otherwise false
      let signalIfAliveDep (wr: WeakReference<IDependent>) =
          wr |> WeakRef.execute (fun dep -> dep.UpdateDirtyFlag dep)
      let signalObserver (v : Lazy<'a>) (obs : IObserver<'a>) =
          obs.OnNext(v.Force())
  
  
negative.code: 
  /// 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
  