anchor.diff:  
       ///Returns the immediate shrinks for the given value based on its type.
       let shrink<'Value> (a:'Value) = from<'Value>.Shrinker a
  +
  +    ///The generic shrinker should work for most number-like types.
  +    let inline shrinkNumber n =
  +        let (|>|) x y = abs x > abs y 
  +        let two = LanguagePrimitives.GenericOne + LanguagePrimitives.GenericOne
  +        seq {   if n < LanguagePrimitives.GenericZero then yield -n
  +                if n <> LanguagePrimitives.GenericZero then yield LanguagePrimitives.GenericZero
  +                yield! Seq.unfold (fun st -> let st = st / two in Some (n-st, st)) n 
  +                        |> Seq.takeWhile ((|>|) n) }
  +        |> Seq.distinct
   
       let internal getGenerator t = (!Arbitrary).GetInstance t |> unbox<IArbitrary> |> (fun arb -> arb.GeneratorObj)
   
  
positive.code:             let gen =
                  Gen.two generate<DontSize<int32>>
                  |> Gen.map (fun (DontSize h, DontSize l) -> (int64 h <<< 32) ||| int64 l)                
              fromGenShrink (gen,Default.GenericValueShrinker)
              |> convert DontSize DontSize.Unwrap
          
          ///Generates arbitrary floats, NaN, NegativeInfinity, PositiveInfinity, Maxvalue, MinValue, Epsilon included fairly frequently.
  
negative.code:             fromGenShrink(gen, shrink)
              |> convert (int16 >> DontSize) (DontSize.Unwrap >> int)
              
          ///Generate arbitrary int32 that is between -size and size.
          static member Int32() = 
              { new Arbitrary<int>() with
                  override x.Generator = Gen.sized <| fun n -> Gen.choose (-n,n) 
                  override x.Shrinker n = shrinkNumber n
              }
  
          ///Generate arbitrary int32 that is between Int32.MinValue and Int32.MaxValue
  