anchor.diff:  open System.Reflection
   open Random
   open Microsoft.FSharp.Control
  -//open Microsoft.FSharp.Reflection
  +open Microsoft.FSharp.Reflection
    
  -type IGen = 
  -    abstract member AsGenObject : Gen<obj>
  +type internal IGen = 
  +    abstract AsGenObject : Gen<obj>
  +    
  +///Generator of a random value, based on a size parameter and a randomly generated int.
   and Gen<'a> = 
  -    Gen of (int -> StdGen -> 'a)   
  +    Gen of (int -> StdGen -> 'a) 
  +        ///map the given function to the value in the generator, yielding a new generator of the result type.  
           member x.Map<'a,'b> (f: 'a -> 'b) : Gen<'b> = match x with (Gen g) -> Gen (fun n r -> f <| g n r)
       interface IGen with
           member x.AsGenObject = x.Map box
           //match x with (Gen g) -> Gen (fun n r -> g n r |> box)
   
  +///Obtain the current size. sized g calls g, passing it the current size as a parameter.
   let sized fgen = Gen (fun n r -> let (Gen m) = fgen n in m n r)
   
  +///Override the current size of the test. resize n g invokes generator g with size parameter n.
   let resize n (Gen m) = Gen (fun _ r -> m n r)
   
  +///Default generator that generates a random number generator. Useful for starting off the process
  +///of generating a random value.
   let rand = Gen (fun n r -> r)
   
   //generates a value out of the generator with maximum size n
  -let generate n rnd (Gen m) = 
  +let private generate n rnd (Gen m) = 
       let size,rnd' = range (0,n) rnd
       m size rnd'
   
  +///The workflow type for generators.
   type GenBuilder () =
       member b.Return(a) : Gen<_> = 
           Gen (fun n r -> a)
  
positive.code: 
  type Result = { ok : option<Lazy<bool>>
                  stamp : list<string>
                  arguments : list<string> }
  
  let nothing = { ok = None; stamp = []; arguments = [] }
  
  
negative.code:         Array.zip (a.GetGenericArguments()) (f.GetGenericArguments())
          |> Array.iter (fun (act,form) -> resolve act form 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<_,_>()
  