anchor.diff:      | Dynamic
       
     type Tree
  -    // Simple
       = String of string
       | Number of double
       | Boolean of bool
  
positive.code:     | Ternary of Tree * Tree * Tree
      | Switch of Tree * Cases list
      | Comma of Tree * Tree
  
      // Exception
      | Try of Tree * Tree option * Tree option
      | Catch of string * Tree
      | Throw of Tree
  
      //
      | Var of Tree
      | Identifier of string
      | Block of Tree list
  
negative.code:         modifyCurrent (Scope.decrLocal name) sc
          tree
  
      let traverseAst (f:Tree->unit) (ast:Tree) =
        match ast with
        | Identifier _
        | Boolean _
        | String _
        | Number _
        | Break _
        | DlrExpr _
        | Continue _
        | Regex(_, _)
        | Pass
        | Null
        | This
        | Undefined -> ()
         
        | Throw t
        | Return t
        | Eval t 
        | Var t
        | Catch(_, t) 
        | Property(t, _)
        | Index(t, _)
        | Unary(_, t)
        | Label(_, t)
        | Convert(_, t) 
        | Function(_, _, t) -> f t
        
        | Comma(a, b)
        | While(_, a, b)
        | DoWhile(_, a, b)
        | With(a, b)
        | Binary(_, a, b)
        | Assign(a, b) ->
          f a
          f b
  
        | Invoke(t, xs) 
        | New(t, xs) -> 
          f t
          for x in xs do f x
  
        | Block xs
        | Array xs -> 
          for x in xs do f x
  
        | ForIn(_, a, b, c)
        | Ternary(a, b, c) -> 
          f a 
          f b 
          f c
  
        | Object xs -> 
          for _, x in xs do f x
  
        | Switch(t, xs) -> 
          f t
  
          for x in xs do
            match x with
            | Case(t, b) ->
              f t
              f b 
  
            | Default(b) ->
              f b
              
        | IfElse(a, b, c) -> 
          f a
          f b
  
          match c with
          | Some c -> f c
          | None -> ()
  
          
        | For(_, a, b, c, d) ->
          f a
          f b
          f c
          f d
   
        | Try(a, b, c) -> 
          f a
  
          match b with
          | Some b -> f b
          | _ -> ()
  
          match c with
          | Some c -> f c
          | _ -> ()
  
      (**)
      let walkAst f tree = 
        match tree with
  