anchor.diff:          | Sequential(x,y) ->
               toCallResult abstractType x @ toCallResult abstractType y
           | Call(None, mi, [lhs;rhs]) when hasAttribute typeof<ArrowAttribute> mi -> 
  -            let mi, args = toCall abstractType lhs
  +            let mi, args = toCallOfType abstractType lhs
               let returns = ReturnValue(rhs.EvalUntyped(), mi.ReturnType)
               [mi,(args,returns)]
           | expr -> invalidOp(expr.ToString())
  
positive.code:     /// Specifies a method or property of the abstract type as a quotation
      member this.Setup(f:'TAbstract -> Expr<'TReturnValue>) =
          let default' = Unchecked.defaultof<'TAbstract>
          let call = toCall abstractType (f default')
          ResultBuilder<'TAbstract,'TReturnValue>(mode,call,calls)
      /// Specifies an event of the abstract type as a quotation
      member this.SetupEvent(f:'TAbstract -> Expr<'TEvent>) =
  
negative.code:             | Call(_, mi, [pred]) when hasAttribute typeof<PredicateAttribute> mi -> 
                  Pred(pred.EvalUntyped())
              | expr -> expr.EvalUntyped() |> Arg |]
      /// Converts expression to a tuple of Expression, MethodInfo and Arg array
      let toCall = function
          | Call(Some(x), mi, args) -> x, mi, toArgs args
          | PropertyGet(Some(x), pi, args) -> x, pi.GetGetMethod(), toArgs args
          | PropertySet(Some(x), pi, args, value) -> x, pi.GetSetMethod(), toArgs args
          | expr -> raise <| NotSupportedException(expr.ToString())
      /// Converts expression to a tuple of MethodInfo and Arg array
      let toCallOfType abstractType expr =
          match toCall expr with
          | x, mi, args when x.Type = abstractType -> mi, args
          | _ -> raise <| NotSupportedException(expr.ToString())
      /// Converts expression to a tuple of MethodInfo, Arg array and Result
  