anchor.diff:          ///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))
  -            }      
  +            generate<DoNotSize<uint64>>
  +            |> Gen.map (fun (DoNotSize n) -> (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() =
  
positive.code:         ///Generate a nullable value that is null 1/8 of the time.
          static member Nullable() = 
              { new Arbitrary<Nullable<'a>>() with
                  override __.Generator = Gen.frequency [(1, gen { return Nullable() }); (7, Gen.map Nullable generate)]
                  override __.Shrinker o =
                      if o.HasValue
                          then seq { yield Nullable(); for x' in shrink o.Value -> Nullable x' }
  
negative.code:         ///Generates uniformly distributed Decimal values in range [0; 1).
          static member private stdDecimalGen =
  #if !NETSTANDARD1_0
              let tenPow7 = 1_000_000_0
              let p = 
                  Gen.choose(0, tenPow7 - 1) 
                  |> Gen.map bigint  
              Gen.map4
                  (fun p1 p2 p3 p4 ->
                  let tenPow7 = bigint tenPow7
                  p1 * tenPow7 * tenPow7 * tenPow7 +
                  p2 * tenPow7 * tenPow7 +
                  p3 * tenPow7 +
                  p4)
                  p p p p
              |> Gen.map
                  (fun mant ->
                      let tenPow7 = decimal tenPow7
                      let mant = decimal mant
                      mant / tenPow7 / tenPow7 / tenPow7 / tenPow7)
  //.NET Standard 1.0 doesn't have explicit conversion from bigint to decimal.
  //Thus, in this case we use only 9 significant bits.
  //It isn't that trivial to implement own conversion and corefx one use
  