anchor.diff:      /// 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')
  +        let call = toCallOfType 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>) =
  
positive.code:         | 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 returns = ReturnValue(rhs.EvalUntyped(), mi.ReturnType)
              [mi,(args,returns)]
          | expr -> invalidOp(expr.ToString())
  
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
  