anchor.diff:      |> Gen.suchThat ((<>) null)
       |> Gen.suchThat (Seq.toList >> isValidJsonString)
   
  -let jsonValueGen : Gen<JsonValue> =  
  -
  -    let stringValGen = Gen.map JsonValue.String validJsonStringGen
  -    let booleanValGen = Gen.map JsonValue.Boolean Arb.generate<bool>
  -    let nullValGen = Gen.constant JsonValue.Null
  -    let numberValGen = Gen.map JsonValue.Number Arb.generate<decimal>
  -
  -    let recordGen record =
  -        record
  -        ||> Gen.map2 (fun x y -> (x,y)) 
  -        |> Gen.listOf
  -        |> Gen.map List.toArray
  -        |> Gen.map JsonValue.Record
  -    
  -    let rec tree() =
  -        let tree' s =
  -            match s with
  -            | 0 -> Gen.oneof [ booleanValGen; stringValGen; nullValGen; numberValGen ]
  -            | n when n>0 -> 
  -                let subtree = 
  -                    (validJsonStringGen, tree()) 
  -                    |> recordGen
  -                    |> Gen.resize (s|>float|>sqrt|>int) 
  -                let arrayGen =
  -                    tree()
  -                    |> Gen.listOf
  -                    |> Gen.map List.toArray
  -                    |> Gen.map JsonValue.Array
  -                    |> Gen.resize (s|>float|>sqrt|>int) 
  -                Gen.oneof [ subtree; arrayGen; booleanValGen; stringValGen; nullValGen; numberValGen ]
  -            | _ -> invalidArg "s" "Only positive arguments are allowed"
  -        Gen.sized tree'
  -
  -    (validJsonStringGen, tree())
  -    |> recordGen
  -
  -let canonicalizeNumString (s :string) =
  -    let hasOnlyZeros = 
  -        Seq.filter Char.IsDigit >> Seq.forall ((=) '0')
  -    if (s |> hasOnlyZeros)
  -    then "0"
  -    else s
  -
  -let numberStringGen : Gen<string> =
  -    let concat gs =
  -        gs
  -        |> Gen.sequence
  -        |> Gen.map (String.concat String.Empty)
  -    
  -    let emptyGen = Gen.constant String.Empty
  -    let signGen = Gen.frequency [20, Gen.constant "-"; 80, emptyGen]
  -
  -    let decimalPrec = 28
  -
  -    let digGen listGenFun =
  -        Gen.choose(0,9)
  -        |> Gen.map Convert.ToString
  -        |> listGenFun
  -        |> Gen.resize (decimalPrec/2)
  -        |> Gen.map (String.concat String.Empty)
  -
  -    let digitsGen = digGen Gen.listOf
  -    let nonEmptyDigitsGen = digGen Gen.nonEmptyListOf
  -
  -    let zeroGen = Gen.constant "0"
  -    let nonZeroDigitGen = Gen.choose(1,9) |> Gen.map Convert.ToString
  -    
  -    let integerPartGen = Gen.frequency 
  -                          [40, zeroGen; 
  -                           60, concat [nonZeroDigitGen; digitsGen]]
  -
  -    let fractionPartGen = Gen.oneof
  -                            [emptyGen;
  -                             concat [Gen.constant "."; nonEmptyDigitsGen]]
  -
  -    [signGen; integerPartGen; fractionPartGen]
  -    |> concat
  -    |> Gen.map canonicalizeNumString
  -
   let jsonStringGen : Gen<string> =
    
       let validJsonStringGen' = 
  
positive.code:     let rec tree() =
          let tree' s  =
              match s with
              | 0 -> Gen.oneof [validJsonStringGen'; boolGen; nullGen; numberStringGen]
              | n when n>0 ->
                  let subtree =
                      (validJsonStringGen', tree())
  
negative.code:         let jsonValue = JsonValue.Parse s
          jsonValue.ToString(JsonSaveOptions.DisableFormatting) = s
      let jsonStringArb = Arb.fromGen (jsonStringGen)
      
      Check.One ({Config.QuickThrowOnFailure with MaxTest = 10000},
                (Prop.forAll jsonStringArb stringifyParsed))