anchor.diff:  let testTree2InPersistent = testTree2 |> buildPeristent
   test ((Mod.force testTree2InPersistent) = PNode(PNode(PLeaf(1),PLeaf(2)), PLeaf 10))
   
  -// let us modify the mod tree and see how the persistent one looks like
  +// let us modify the mod tree and see how the persistent representation looks like
   transact (fun () -> Mod.change l2 l2Original)
   
   test ((Mod.force testTree2InPersistent) = PNode(PNode(PLeaf 1, PLeaf 2), PNode(PLeaf 3, PLeaf 4)))
  
positive.code:                          
  // (b) done.
  
  // Let us convert the tree to a adaptive one
  type Tree<'a> = Node of left : IMod<Tree<'a>> * right : IMod<Tree<'a>> 
                | Leaf of IMod<'a>
  
  
negative.code: // by the way, our modification also updated our leaf list
  test (testTree2 |> leafNodes |> setEqual [1;2;3;4])
  
  // (just for presentation purpose i use a separate module which allows me to reuse variable names for top level bindings)
  module UndoRedo =
      // lets go on and move on to undo-redo
      // in order to implement undo redo generically, but not globally we introduce
      // a scope (e.g. camera moves shall not be tracked globally).
      // the undo redo scope acts as factory for IModRef values but tracks snapshots for them.
      // please note that the undo-redo s<stem here was just a 40 line sketch by gh. But as you will see,
      // this solution is so beautiful, concise, efficient and awesome.
  
      let scope = UndoRedoScope()
      // let us now create a tree just as before but we use special mod ctors 
  
      // let us now create the tree just like before but by using the undo redo scope
      let leaf v = Leaf (scope.initMod v)
  