anchor.diff:          FST.GetUnionCases(t, flags)
           |> Array.map (fun c ->
               let mk = FSV.PreComputeUnionConstructor(c, flags)
  +            let fields = c.GetFields()
  +            let mk, fields =
  +                if isInlinableRecordCase c then
  +                    let rt = fields.[0].PropertyType
  +                    let mkR = FSV.PreComputeRecordConstructor(rt, flags)
  +                    let mk x = mk [|mkR x|]
  +                    mk, FST.GetRecordFields(rt, flags)
  +                else mk, fields
               let fs =
  -                c.GetFields()
  +                fields
                   |> Array.mapi (fun k f ->
                       i.GetEncodedUnionFieldName f k, decodeOptionalField dD i f f.PropertyType)
               (mk, fs))
  
positive.code:     let cases =
          FST.GetUnionCases(t, flags)
          |> Array.map (fun c ->
              let fields =
                  c.GetFields()
                  |> Array.filter (fun f ->
                      let t = f.PropertyType
                      not (t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<option<_>>))
  
negative.code:         FST.GetUnionCases(t, flags)
          |> Array.map (fun c ->
              let r = FSV.PreComputeUnionReader(c, flags)
              let fields = c.GetFields()
              let r, fields =
                  if isInlinableRecordCase c then
                      let rt = fields.[0].PropertyType
                      let rr = FSV.PreComputeRecordReader(rt, flags)
                      let r x = rr (r x).[0]
                      r, FST.GetRecordFields(rt, flags)
                  else r, fields
              let fs = fields |> Array.mapi (fun k f ->
                  i.GetEncodedUnionFieldName f k, encodeOptionalField dE i f f.PropertyType)
              (r, fs))
      let encodeTag = i.EncodeUnionTag t
      fun (x: obj) ->
  