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: 
      let decodeObject =
          object5 (fun name number maybeNumber list map ->
              { Name = name
                Number = number
                MaybeNumber = maybeNumber
                List = list
                Map = map })
              ("name" := oneOf [ dnull null; dstring ])
              ("number" := dint)
              ("maybeNumber" := maybe dint)
              ("list" := decodeList)
              ("map" := decodeMap)
  
      let rec decodeUnion =
          ("type" := dstring) >>= function
              | "single" -> succeed Single
              | "record" -> object1 Record decodeObject
              | "complex" ->
                  object2
                      (fun n xs -> Complex (n, xs))
                      ("number" := dint)
                      ("list" := decodeList)
              | "recursive" ->
                  object1 Recursive ("data" := decodeUnion)
              | _ -> invalidOp ""
  
  module Generators =
  