anchor.diff:              | PropertySet(Some(x), pi, args, value) -> 
                   x, pi.GetSetMethod(), toArgs [yield! pi.GetIndexParameters();yield null] [yield! args;yield value]
               | expr -> raise <| NotSupportedException(expr.ToString())
  -
  +        // Handle applications of functions and standard functions
           match quote with
           | Application (_, _) -> unwrapApplication quote
           | _ -> unwrapStandard quote
  -
  -    /// Converts expression to a tuple of MethodInfo and Arg array
  +    /// Converts expression to call checking expected type
       let toCallOf 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
  +    /// Converts Mock.With expressions to calls with expected results list
       let rec toCallResult = function
           | ForIntegerRangeLoop(v,a,b,y) -> [for i = eval a :?> int to eval b :?> int do yield! toCallResult y]
           | Sequential(x,y) -> toCallResult x @ toCallResult y
  
positive.code:     open Eval
      /// Returns true if method has specified attribute
      let hasAttribute a (mi:MethodInfo) = mi.GetCustomAttributes(a, true).Length > 0
      /// Converts expression to a tuple of MethodInfo and Arg array
  
      let toCallArg arg = 
          match arg with
          | Call(_, mi, _) when hasAttribute typeof<WildcardAttribute> mi -> Any
          | Call(_, mi, [pred]) when hasAttribute typeof<PredicateAttribute> mi -> Pred(eval pred)
          | _ -> raise (NotSupportedException ())
  
      let rec toArg (pi:ParameterInfo,arg) =
          match pi, arg with
          | _, Call _ -> toCallArg arg
          | pi, NewArray(_,args) when pi <> null && pi.GetCustomAttributes(typeof<ParamArrayAttribute>, true).Length > 0 ->
             ArgArray [|for arg in args -> toArg(null, arg)|]
          | _, expr -> eval expr |> Arg 
      let toArgs ps args = [|for arg in Seq.zip ps args -> toArg arg |]
      /// Active pattern matches method call expressions
      let (|MethodCall|_|) expr =
  
negative.code:         | PropertySet(Some(x), pi, args, value) ->
              [x, pi.GetSetMethod(),(toArgs [|yield! pi.GetIndexParameters(); yield null|] [yield! args; yield value], Unit)]
          | expr -> invalidOp(expr.ToString())
      /// Converts Mock.With expressions to call/result list checking expected type
      let rec toCallResultOf abstractType expr =
          let calls = toCallResult expr
          [for (x,mi,(arg,result)) in calls -> 
  