anchor.diff:  type MapKey = Key of string
   
   type ListObject = {
  -    Number: float
  +    Int: int
  +    Float: float
  +    Decimal: decimal
  +    Tuple: (int * string)
   }
   
   type MapObject = {
       List: ListObject list
   }
   
  -type Object = {
  +type Record = {
       Name: string
       Number: int
       MaybeNumber: int option
  
positive.code:     let encodeMapObject (o: MapObject) =
          jobject [ "list", encodeList o.List ]
  
      let encodeMap (map: Map<_, _>) =
          Seq.map (fun (KeyValue(Key k, v)) -> k, encodeMapObject v) map
          |> jobject
  
      let encodeObject o =
          [ "name",  if o.Name = null then jnull else jstring o.Name
            "number", jint o.Number
            "maybeNumber", o.MaybeNumber |> Option.map jint |> Option.defaultValue jnull
            "list", encodeList o.List
            "map", encodeMap o.Map ]
  
      let encodeUnion = function
          | Object o -> jobject (("type", jstring "object") :: encodeObject o)
          | Number n -> jobject [ "type", jstring "number"; "n", jint n ]
  
  module Decoders =
      let decodeListObject =
          object1
              (fun number -> { ListObject.Number = number })
              ("number" := dfloat)
  
      let decodeList =
          dlist decodeListObject
  
negative.code: }
  
  type Union =
      | Single
      | Record of Record
      | Complex of int * ListObject list
      | Recursive of Union
  
  module Encoders =
      let encodeListObject (o: ListObject) =
          jobject
              [ "int", jint o.Int
                "float", jfloat o.Float
                "decimal", jdecimal o.Decimal
                "tuple",
                  jlist
                      [ jint (fst o.Tuple)
                        jstring (snd o.Tuple) ] ]
  
      let encodeList =
          jlist << List.map encodeListObject
  