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: }
  
  type Union =
      | Object of Object
      | Number of int
  
  module Encoders =
      let encodeListObject (o: ListObject) =
          jobject [ "number", jfloat o.Number ]
  
      let encodeList =
          jlist << List.map encodeListObject
  
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 =
  