anchor.diff:      open System.Collections.Generic
       open TypeClass
   
  -    ///Apply ('map') the function f on the value in the generator, yielding a new generator.
  +    ///Apply the function f to the value in the generator, yielding a new generator.
  +    ///[category: Building generators out of existing generators]
  +    [<CompiledName("Map")>]
       let map f (gen:Gen<_>) = gen.Map f
   
       ///Obtain the current size. sized g calls g, passing it the current size as a parameter.
  +    ///[category: Managing size]
  +    [<CompiledName("Sized")>]
       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.
  +    ///[category: Managing size]
  +    [<CompiledName("Resize")>]
       let resize n (Gen m) = Gen (fun _ r -> m n r)
   
       ///Generates a random number generator. Useful for starting off the process
  
positive.code:                   let! cols = chooseSqrtOfSize
                    return! array2DOfDim (rows,cols) g }
          
      ///Always generate v.          
      let constant v = gen { return v }
  
      ///Apply the given Gen function to the given generator, aka the applicative <*> operator.
      let apply (f:Gen<'a -> 'b>) (gn:Gen<'a>) : Gen<'b> =
          gen { let! f' = f
                let! gn' = gn
  
negative.code:                                             return f a' b' c' d' e' g'}
  
      ///Sequence the given seq of generators into a generator of a list.
      ///[category: Creating generators from generators]
      [<CompiledName("Sequence")>]
      let sequence l = 
          let rec go gs acc size r0 = 
              match gs with
  