anchor.diff:            member jm.ToJson (e, o) =
               Map.add eL.Name (eJ.ToJson e) o} : JsonP<'e,'r,'o,'t>
   
  -    static member OptElem (eL: Labelled<option<'e>,'r,'o,'t>, eJ: JsonO<'e>) =
  -      P {new JsonI<option<'e>> () with
  +    static member OptElem (eL: Labelled<option<'e>,'r,'o,'t>, eJ: JsonValue<'e>) =
  +      P {new JsonObj<option<'e>> () with
             member jm.OfJson (o, eO) =
              match Map.tryFind eL.Name o with
               | None -> eO <- None; None
  
positive.code:              | None -> o
               | Some e -> Map.add eL.Name (eJ.ToJson e) o}
  
      static member Pair (P eJ: JsonP<'e,Pair<'e,'r>,'o,'t>,
                          P rJ: JsonP<'r,        'r ,'o,'t>) =
        P {new JsonI<Pair<'e,'r>> () with
            member jm.OfJson (o, er) =
              match eJ.OfJson (o, &er.Elem) with
               | None -> rJ.OfJson (o, &er.Rest)
  
negative.code: 
    type Is<'t> = | Is
  
    type JsonValue<'t> =
      {OfJson: Value -> Choice<'t, string>
       ToJson: 't -> Value}
  
    type [<AbstractClass>] JsonObj<'t> () =
      abstract OfJson: Obj * byref<'t> -> option<string>
      abstract ToJson: byref<'t> * Obj -> Obj
  
    type [<AbstractClass>] JsonArray<'t> () =
      abstract OfJson: list<Value> * byref<'t> -> option<string>
      abstract ToJson: byref<'t> -> list<Value>
  
    type JsonA<'e,'r,'t> = A of JsonArray<'e>
    type JsonP<'e,'r,'o,'t> = P of JsonObj<'e>
    type JsonS<'p,'o,'t> = S of list<JsonValue<'t>>
  
    let number (ofString: string -> 't) (toString: 't -> string) =
      {OfJson = function (Number v) -> v |> ofString |> Choice1Of2
  