• #56: Add JsonUnionEncoding.UnwrapRecordCases, which implies JsonUnionEncoding.NamedFields and encodes union cases containing a single record field as if the record's fields were the union's fields instead. For example:

  type U =
      | U of r: {| x: int; y: bool |}
  
  U {| x = 1; y = true |}
  // Serialized as: {"Case":"U","Fields":{"x":1,"y":true}}
  // Instead of:    {"Case":"U","Fields":{"r":{"x":1,"y":true}}}
  

  This option is compatible with all union formats (AdjacentTag, ExternalTag, InternalTag and Untagged).
• #64: Fix serialization of unit as field of an F# type. Thanks @NickDarvey!

• #54: Do throw an exception when a mandatory field is missing and an optional field was omitted. Thanks @fuchen!

• #57: Do throw an exception when a parsed value is null inside an array, a set or a tuple, unless allowNullFields is true. Thanks @drhumlen!

• #47: Add Skippable<'T> to represent values that can be omitted from the serialization of a record or a union with NamedFields. This is particularly useful with Skippable<'T option> (or voption) to represent a field that can be omitted, null, or have a proper value.

  type R = { x: Skippable<int option> }
  
  { x = Skip }              // Serialized as: {}
  { x = Include None }      // Serialized as: {"x":null}
  { x = Include (Some 42) } // Serialized as: {"x":42}
  

  Also add a Skippable module with standard functions: map, filter, etc. Implementation largely based on @cmeeren's JsonSkippable which provides the same functionality for Newtonsoft.Json.
• #51: When the type K is a single-case union wrapping a string, serialize Map<K, V> into a JSON object, like Map<string, V>.
• Allow OR-ing a base JsonUnionEncoding (AdjacentTag, InternalTag, ExternalTag or Untagged) with Default to use the default extra options (UnwrapOption ||| UnwrapSingleCaseUnions).

• #43: In deserialization, allow omitting fields that are optional.
• In deserialization, when a field is missing, find which one it is and name it in the error message.

• #30: Unwrap 'T voption with JsonUnionEncoding.UnwrapOption. Thanks @johlrich!

• #32: Add JsonUnionEncoding.UnwrapSingleFieldCases, which encodes the field of single-field cases as x instead of [x]. Include it in JsonUnionEncoding.FSharpLuLike.

• #33: Fix "read too much or not enough" when parsing a list of unions with JsonUnionEncoding.UnwrapFieldlessTags.

• #36: BREAKING CHANGE: During deserialization, throw an exception when a field of a record or union has value null, unless the type of this field is option, voption, or a union with UseNullAsTrueValue. Thanks @drhumlen!

  New option allowNullFields disables this behavior.

• #38: Add more consistent names for options:

  • BareFieldlessTags becomes UnwrapFieldlessTags;
  • SuccintOption becomes UnwrapOption;
  • EraseSingleCaseUnions becomes UnwrapSingleCaseUnions.

  The previous names are marked Obsolete.

• #3: Add support for PropertyNamingPolicy on record and union fields.
• #22: Add support for DictionaryKeyPolicy for Map<string, 'T>.
• #27: Add unionTagNamingPolicy option to JsonFSharpConverter and JsonFSharpConverterAttribute to customize the naming policy for union tag names.
• #26: Add JsonUnionEncoding.EraseSingleCaseUnions, which encodes single-case single-field unions the same as the value in the field.
  BREAKING CHANGE: This is now the default option.
• #5: Add support for PropertyNameCaseInsensitive on record and union fields.
  Add unionTagCaseInsensitive option to JsonFSharpConverter and JsonFSharpConverterAttribute to customize the case sensitivity for union tag names.

• #4: Add support for standard option IgnoreNullValues on record and union fields.
• #13: Add support for JsonPropertyNameAttribute on union cases to set the tag name to use for this case.
• #16: Add JsonUnionEncoding.SuccintOption, which encodes Some x the same as x.
  BREAKING CHANGE: This is now the default option.
• Add unionTagName and unionFieldsName option to customize the "Case" and "Fields" tags for unions.
• Add JsonUnionEncoding.FSharpLuLike, which is equivalent to ExternalTag ||| BareFieldlessTags ||| SuccintOption.

Initial release.

• Serialize and deserialize F# unions and struct unions.
• Serialize and deserialize F# records, struct records and anonymous records.

New features

• #1 Record fields now honor JsonPropertyNameAttribute.
• #2 Record fields now honor JsonIgnoreAttribute.

Improvements

• #9 The information about whether a type is a record or a union is now cached.
• #12 The package now targets .NET Standard 2.0 and can therefore also be used on .NET Framework.

New features

• #6 Add different encodings for F# unions.
  • JsonFSharpConverter and JsonFSharpConverterAttribute now take JsonUnionEncoding as optional argument.
  • Unions are encoded depending on the JsonUnionEncoding as detailed in the documentation.

New features

• #17 Add encoding of collections:
  • 'T list encoded as JSON array.
  • Set<'T> encoded as JSON array.
  • Map<string, 'T> encoded as JSON object with map keys as field names.
  • Map<'K, 'V> when 'K is not string encoded as JSON array whose elements are [key,value] JSON arrays.
  • Tuples and struct tuples encoded as JSON array.