anchor.diff:                                      o.Level <- max o.Level (level + 1)
                                   | _ -> ()
   
  -                            outOfDate <- false
  +                            
                               r
                           finally
                               stack.Pop() |> ignore
  
positive.code: open System.Collections.Concurrent
  open System.Threading
  
  type VolatileCollection<'a when 'a : not struct>() =
      let set = HashSet<'a>()
  
      member x.IsEmpty = lock set (fun () -> set.Count = 0)
  
      member x.Consume() : seq<'a> =
          lock set (fun () -> 
              let arr = set |> Seq.toArray
              set.Clear()
              arr :> _
          )
  
      member x.Add(value : 'a) : bool =
          lock set (fun () -> set.Add value)
  
      member x.Remove(value : 'a) : bool =
          lock set (fun () -> set.Remove value)
  
      member x.Seq = set |> Seq.toList :> seq<'a>
  
  /// <summary>
  /// IAdaptiveObject represents the core interface for all
  
negative.code:                             // This property must therefore be maintained for every
                              // path in the entire system.
                              let r = f()
                              outOfDate <- false
  
                              // if the object's level just got greater than or equal to
                              // the level of the running transaction (if any)
  