anchor.diff:          
   
       [<Test>]
  +    let ``[Mod] fan out, different eval strategy``() =
  +
  +        let input = Mod.init 10
  +
  +        let middle = input |> Mod.map id
  +        let outputA = middle |> Mod.map id
  +        let outputB = middle |> Mod.map id
  +        let mutable marked = false
  +        outputB.AddMarkingCallback(fun () -> marked <- true) |> ignore
  +
  +        outputA |> Mod.force |> should equal 10
  +        marked |> should equal true
  +
  +
  +    [<Test>]
       let ``[Mod] mod concurrency test super crazy callbacks``() =
           
           let pulledValues = List<int>()
  
positive.code: 
          //collection.Count |> should equal 0
          printfn "awaited"
          //result |> should equal currentValue
          derived |> Mod.force |> should equal currentValue
          printfn "done"
  
  
negative.code: 
          let derived = middle |> Mod.map id |> Mod.map (fun s -> Thread.Sleep 5; s) 
  
          let maxCnt = 400
          let mutable abort = false
          let mutable currentValue = 0
          let inputThread = System.Threading.Thread(ThreadStart(fun _ ->
              for i in 1 ..maxCnt do
                  let newValue = Interlocked.Increment(&currentValue)
                  transact (fun () -> Mod.change input newValue)
              abort <- true
          ))
  
          let mutable marked = 0
          let d = derived.AddMarkingCallback (fun _ -> Interlocked.Increment(&marked) |> ignore)
  
          let collection = new System.Collections.Concurrent.BlockingCollection<int>()
  
  