anchor.diff:          ///Generates an interval between two non-negative integers.
           static member Interval() =
               let generator = 
  -                  gen { let! start,offset = Gen.two generate
  -                  return Interval (abs start,abs start+abs offset) }
  +                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
  
positive.code: 
          static member KeyValuePair() =
              let genKeyValuePair =
                  gen {
                      let! key = generate
                      let! value = generate
                      return KeyValuePair(key, value)
                  }
              let shrinkKeyValuePair (kvp:KeyValuePair<_,_>) = 
                  seq { for key in shrink kvp.Key do
                          for value in shrink kvp.Value do
  
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
  