anchor.diff:  
           ///Generates an interval between two non-negative integers.
           static member Interval() =
  -            { new Arbitrary<Interval>() with
  -                override  __.Generator = 
  +            fromGen <| 
                       gen { let! start,offset = Gen.two generate
  -                          return Interval (abs start,abs start+abs offset) } //TODO: shrinker
  -            }
  +                          return Interval (abs start,abs start+abs offset) }//TODO: shrinker
  +
   
           static member StringWithoutNullChars() =
               from<string>
  
positive.code:         
          ///Generates (), of the unit type.
          static member Unit() = 
              { new Arbitrary<unit>() with
                  override __.Generator = gen { return () } 
              }
          ///Generates an arbitrary bool.
          static member Bool() = 
              { new Arbitrary<bool>() with
                  override __.Generator = Gen.elements [true; false] 
              }
          ///Generates an arbitrary byte.
          static member Byte() =
              { new Arbitrary<byte>() with
                  override __.Generator = 
                      Gen.choose (0,255) |> Gen.map byte //this is now size independent - 255 is not enough to not cover them all anyway 
                  override __.Shrinker n = n |> int |> shrink |> Seq.map byte
              }
          ///Generates an arbitrary signed byte.
          static member SByte() =
              { new Arbitrary<sbyte>() with
                  override __.Generator = 
                      Gen.choose (-128,127) |> Gen.map sbyte 
                  override __.Shrinker n = 
                    n |> int |> shrink 
                    |> Seq.filter (fun e -> -128 <= e && e <= 127) //the int shrinker shrinks -128 to 128 which overflows
                    |> Seq.map sbyte
              }
          ///Generate arbitrary int16 that is between -size and size.
          static member Int16() =
              from<int>
  
negative.code:             
          ///Generate arbitrary int32 that is between -size and size.
          static member Int32() = 
              fromGenShrink ( Gen.sized (fun n -> Gen.choose (-n,n)),
                              shrinkNumber)
  
          ///Generate arbitrary int32 that is between Int32.MinValue and Int32.MaxValue
          static member DontSizeInt32() =
  