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: #endif
          static member Decimal() =
              let generator = Gen.sized (fun size ->
                  gen {
                      let! d = Default.stdDecimalGen
                      return d * (Decimal size)
                  })
              let shrinker d =
                  let (|<|) x y = abs x < abs y
                  seq {
  
negative.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.fresh Nullable); (7, Gen.map Nullable generate)]
                  override __.Shrinker o =
                      if o.HasValue
                          then seq { yield Nullable(); for x' in shrink o.Value -> Nullable x' }
  