anchor.diff:      /// Note that this function takes care of appropriate locking
       /// </summary>
       member x.EvaluateAlways (f : unit -> 'a) =
  -        let top = isTopLevel.Value
  -        if top then isTopLevel.Value <- false
  -
  -        let res =
  -            lock x (fun () ->
  -                IncrementalLog.startEvaluate x
  -                let res = f()
  -                x.OutOfDate <- false
  -                IncrementalLog.endEvaluate x
  -                res
  -            )
  -
  -        if top then 
  -            isTopLevel.Value <- true
  -            if not time.Outputs.IsEmpty then
  -                let t = Transaction()
  -                for o in time.Outputs.Consume() do
  -                    t.Enqueue(o)
  -                t.Commit()
  -
  -
  -        res
  +        evaluate x None f
   
   
       member x.Id = id
  
positive.code:     
  
  /// <summary>
  /// IncrementalLog logs a the sequence of fundamental adaptive operations
  /// performed by the system. This allows to investigate bugs and concurrency
  /// issues. Since this logging is relatively expensive it is disabled by default.
  /// </summary>
  module IncrementalLog =
      open System.Threading
  
      type Operation =
          | StartEvaluate = 1
          | EndEvaluate = 2
          | StartMark = 3
          | EndMark = 4
  
      let private log = List<Operation * int>()
      let private logLock = SpinLock()
  
      let append (op : Operation) (o : IAdaptiveObject) =
          #if DEBUG
          lock log (fun () ->
              log.Add(op,o.Id)
          )
          #else
          ()
          #endif
  
      let inline startEvaluate(o : IAdaptiveObject) =
          append Operation.StartEvaluate o
  
      let inline endEvaluate(o : IAdaptiveObject) =
          append Operation.EndEvaluate o
  
      let inline startMark(o : IAdaptiveObject) =
          append Operation.StartMark o
  
      let inline endMark(o : IAdaptiveObject) =
          append Operation.EndMark o
  
      let getLog() =
          log |> Seq.map (fun (op, o) -> 
              match op with
                  | Operation.StartEvaluate -> sprintf "S(%d)" o
                  | Operation.EndEvaluate -> sprintf "E(%d)" o
                  | Operation.StartMark -> sprintf "MS(%d)" o
                  | Operation.EndMark -> sprintf "ME(%d)" o
                  | _ -> failwithf "unknown operation: %A" op
          ) |> String.concat "\r\n"
  
  /// <summary>
  /// LevelChangedException is internally used by the system
  /// to handle level changes during the change propagation.
  /// </summary>
  
negative.code:         // when the commit is over we restore the old
          // running transaction (if any)
          running.Value <- old
  
  /// <summary>
  /// defines a base class for all adaptive objects implementing
  