anchor.diff:  }
   
   type Union =
  -    | Object of Object
  -    | Number of int
  +    | Single
  +    | Record of Record
  +    | Complex of int * ListObject list
  +    | Recursive of Union
   
   module Encoders =
       let encodeListObject (o: ListObject) =
  -        jobject [ "number", jfloat o.Number ]
  +        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
  
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 MapKey = Key of string
  
  type ListObject = {
      Int: int
      Float: float
      Decimal: decimal
      Tuple: (int * string)
  }
  
  type MapObject = {
      List: ListObject list
  }
  
  type Record = {
      Name: string
      Number: int
      MaybeNumber: int option
  