anchor.diff:                                  else Transaction.RunningLevel
   
                               if level > maxAllowedLevel then
  -                                // i am a pull from the future   
  +                                // all greater pulls would be from the future
                                   raise <| LevelChangedException(this, level, stack.Count - 1)
   
   
  
positive.code:                                     o.Level <- max o.Level (level + 1)
                                  | _ -> ()
  
                              outOfDate <- false
                              r
                          finally
                              stack.Pop() |> ignore
  
negative.code: open System.Collections.Concurrent
  open System.Threading
  
  type VolatileCollection<'a>() =
      let mutable set : HashSet<'a> = null
      let mutable pset = []
  
      let rec slowContains (v : 'a) (count : int) (l : list<'a>) =
          match l with
              | [] -> count
              | x::xs ->
                  if System.Object.Equals(x, v) then -1
                  else slowContains v (count + 1) xs
  
      let rec slowRemove (v : 'a) (acc : list<'a>) (l : list<'a>) =
          match l with
              | [] -> (false, acc)
              | x::xs ->
                  if Object.Equals(x, v) then
                      (true, acc @ xs)
                  else
                      slowRemove v (x::acc) xs
  
      member x.IsEmpty = 
          lock x (fun () ->
              if isNull set then List.isEmpty pset
              else set.Count = 0
          )
  
      member x.Consume() : seq<'a> =
          lock x (fun () -> 
              if isNull set then
                  let res = pset
                  pset <- []
                  res :> seq<_>
              else
                  let res = set
                  set <- null
                  res :> _
          )
  
      member x.Add(value : 'a) : bool =
          lock x (fun () -> 
              if isNull set then 
                  let count = slowContains value 0 pset
                  if count < 0 then
                      false
                  else
                      pset <- value::pset
  
                      if count >= 7 then
                          set <- HashSet pset
                          pset <- []
  
                      true
              else
                  set.Add value
          )
  
      member x.Remove(value : 'a) : bool =
          lock x (fun () -> 
              if isNull set then 
                  let (removed, newList) = slowRemove value [] pset
                  if removed then
                      pset <- newList
                      true
                  else
                      false
              else
                  set.Remove value
          )
  
  
  /// <summary>
  /// IAdaptiveObject represents the core interface for all
  