anchor.diff:      let testResult =
           match outcome with
               | Passed _ -> True { NumberOfTests = ntest; Stamps = table }
  -            | Falsified args -> False ({ NumberOfTests = ntest; Stamps = table }, args)
  +            | Falsified (args,exc) -> False ({ NumberOfTests = ntest; Stamps = table }, args, exc)
               | Failed _ -> Exhausted { NumberOfTests = ntest; Stamps = table }
               | _ -> failwith "Test ended prematurely"
       config.runner.OnFinished(config.name,testResult)
  
positive.code: type TestData = { NumberOfTests: int; Stamps: seq<int * list<string>>}
  type TestResult = 
      | True of TestData
      | False of TestData * list<obj> //the arguments that produced the failed test
      | Exhausted of TestData
  type IRunner =
      abstract member OnArguments: int * list<obj> * (int -> list<obj> -> string) -> unit
      abstract member OnFinished: string * TestResult -> unit
  
negative.code:         let mi' = if mi.ContainsGenericParameters then mi.MakeGenericMethod(typeargs) else mi
          mi'.Invoke(null, args)
  
  // resolve fails if the generic type is only determined by the return type 
  //(e.g., Array.zero_create) but that is easily fixed by additionally passing in the return type...
  let rec resolve (acc:Dictionary<_,_>) (a:Type, f:Type) =
      if f.IsGenericParameter then
          if not (acc.ContainsKey(f)) then acc.Add(f,a)
      else 
          if a.HasElementType then resolve acc (a.GetElementType(), f.GetElementType())
          Array.zip (a.GetGenericArguments()) (f.GetGenericArguments()) |>
          Array.iter (resolve acc)
  
  //for invoking functions: http://cs.hubfs.net/forums/thread/7820.aspx
  let invokeMethod (m:MethodInfo) args =
      let m = if m.ContainsGenericParameters then
                  let typeMap = new Dictionary<_,_>()
                  Array.zip args (m.GetParameters()) |> 
                  Array.iter (fun (a,f) -> resolve typeMap (a.GetType(),f.ParameterType))  
                  let actuals = 
                      m.GetGenericArguments() |> 
                      Array.map (fun formal -> typeMap.[formal])
                  m.MakeGenericMethod(actuals)
              else 
                  m
  