anchor.diff:              
           ///Generates arbitrary chars, between ASCII codes Char.MinValue and 127.
           static member Char() = 
  -            { new Arbitrary<char>() with
  -                override __.Generator = Gen.choose (int Char.MinValue, 127) |> Gen.map char
  -                override __.Shrinker c =
  -                    seq { for c' in ['a';'b';'c'] do if c' < c || not (Char.IsLower c) then yield c' }
  -            }
  +            let generator = Gen.choose (int Char.MinValue, 127) |> Gen.map char
  +            let shrinker c = seq { for c' in ['a';'b';'c'] do if c' < c || not (Char.IsLower c) then yield c' }
  +            fromGenShrink (generator, shrinker)
  +
           ///Generates arbitrary strings, which are lists of chars generated by Char.
           static member String() = 
  -            { new Arbitrary<string>() with
  -                override __.Generator = Gen.frequency [(9, Gen.map (fun (chars:char[]) -> new String(chars)) generate);(1, Gen.constant null)]
  -                override __.Shrinker s = 
  +            let generator = Gen.frequency [(9, Gen.map (fun (chars:char[]) -> new String(chars)) generate);(1, Gen.constant null)]
  +            let shrinker (s:string) = 
                       match s with
                       | null -> Seq.empty
                       | _ -> s.ToCharArray() |> Array.toList |> shrink |> Seq.map (fun chars -> new String(List.toArray chars))
  -            }
  +            fromGenShrink (generator,shrinker)
  +
           ///Generate an option value that is 'None' 1/8 of the time.
           static member Option() = 
               { new Arbitrary<option<'a>>() with
  
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() =
  