anchor.diff:  
       static member Case (m: Case<'e,'o,'t>,
                           eL: Labelled<'e,'e,'o,'t>,
  -                        eJ: JsonO<'e>) =
  +                        eJ: JsonValue<'e>) =
         S [(if eL.Name = "Item"
             then {OfJson = eJ.OfJson >> Choice.map m.OfPairs id
                   ToJson = m.ToPairs >> eJ.ToJson}
  
positive.code:           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
            member jm.OfJson (o, eO) =
             match Map.tryFind eL.Name o with
              | None -> eO <- None; None
  
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
  