anchor.diff:              )
   
   
  -        let ofSeq (name : string) (getTraversal : string -> Type -> Expr) (methods : seq<MethodInfo>) =
  +        let ofSeq (name : string) (methods : seq<MethodInfo>) =
               let methods = Seq.toList methods
   
               // try to get definitions for all methods
  
positive.code:                                         if Set.contains n strictInh then
                                              let get = traversalGetValue.MakeGenericMethod [| v.Type |]
                                              Expr.Call(Expr.Var traversal, get, [Expr.Value n])
  
                                          else
                                              if n = name then
                                                  let get = run v.Type
                                                  Expr.Call(Expr.Var traversal, get, [Expr.Var node])
                                              else
                                                  let t = getTraversal n v.Type
                                                  let get = run v.Type
                                                  Expr.Call(t, get, [Expr.Var node])
  
                                      v, replacement
                                     )
  
negative.code:             let node = Var("node", typeof<obj>)
              
              let run t = typedefof<ITraversal<_>>.MakeGenericType([|t|]).GetMethod("Run")
  
  
              let runInherit (t : Type) (n : string) =
                  if n = name then
                      Expr.Call(Expr.Var traversal, run t, [Expr.Var node])
                  else
                      let t = getTraversal n t
                      let t = Expr.Call(t, t.Type.GetMethod "WithState", [Expr.PropertyGet(Expr.Var traversal, traversal.Type.GetProperty "State")])
  
                      Expr.Call(t, t.Type.GetMethod "Run", [Expr.Var node])
  
              let rec build (sfs : list<SemanticFunction>) =
                  match sfs with
  