anchor.diff:  
           static member KeyValuePair() =
               let genKeyValuePair =
  -                gen {
  -                    let! key = generate
  -                    let! value = generate
  -                    return KeyValuePair(key, value)
  -                }
  +                Gen.map2 (fun k v -> KeyValuePair(k, v)) generate generate
               let shrinkKeyValuePair (kvp:KeyValuePair<_,_>) = 
                   seq { for key in shrink kvp.Key do
                           for value in shrink kvp.Value do
  
positive.code:         ///Actually, most of the values in range [0; 1) are NEVER generated.
          ///See "Generating uniform doubles in the unit interval" at http://xoshiro.di.unimi.it/ 
          static member private stdFloatGen =
              gen {
                  let! n = generate<DoNotSize<uint64>> |> Gen.map DoNotSize.Unwrap
                  return (float (n >>> 11)) * (1.0 / float (1UL <<< 53))
              }      
          
          /// Generates a "normal" 64 bit floats between -size and size (without NaN, Infinity, Epsilon, MinValue, MaxValue)
          static member NormalFloat() =
  
negative.code:         ///Generates an interval between two non-negative integers.
          static member Interval() =
              let generator = 
                  generate
                  |> Gen.two
                  |> Gen.map (fun (start, offset) -> Interval (abs start, abs start + abs offset))
              let shrinker (i : Interval) =
                  (i.Left, i.Right - i.Left)
                  |> shrink
  