anchor.diff:      aset {
           match t with 
            | Node(l,r) -> 
  -            let! l = l
  +            let! l = l // children are mod, read them adaptively
               let! r = r
  -            yield! leafNodes l
  +            yield! leafNodes l // then recurse and use yield! 
  +                               // since the rec call returns an aset
               yield! leafNodes r
            | Leaf v ->
               yield v
  
positive.code: #r "System.Reactive.Linq.dll"
  
  (*
  Goal: implement tree like structure
  
  a) provide operations for modifying the tree.
  b) provide some traversal which extracts leaf nodes from the tree.
  c) leaf node extraction should be incremental
  d) provide functional snapshots
  e) undelimited undo/redo while maintainging efficient updates.
  
negative.code: 
  test (resultingLeafNodes |> setEqual [1;2;10])
  
  // (c) done. (incremental fold for adaptive binary trees)
  
  // Okay, we have incremental updates to trees. But what if we want functional snapshots?
  // let us adaptively convert our mod tree to a persistent one!
  