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:             
          ///Generates arbitrary chars, between ASCII codes Char.MinValue and 127.
          static member Char() = 
              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() = 
              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
  