Variant attributes

• #[serde(rename = "name")]

  Serialize and deserialize this variant with the given name instead of its Rust name.

  Allows specifying independent names for serialization vs deserialization:

  • #[serde(rename(serialize = "ser_name"))]
  • #[serde(rename(deserialize = "de_name"))]
  • #[serde(rename(serialize = "ser_name", deserialize = "de_name"))]

• #[serde(alias = "name")]

  Deserialize this variant from the given name or from its Rust name. May be repeated to specify multiple possible names for the same variant.

• #[serde(rename_all = "...")]

  Rename all the fields of this struct variant according to the given case convention. The possible values are "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE".

  Allows specifying independent cases for serialization vs deserialization:

  • #[serde(rename_all(serialize = "..."))]
  • #[serde(rename_all(deserialize = "..."))]
  • #[serde(rename_all(serialize = "...", deserialize = "..."))]

• #[serde(skip)]

  Never serialize or deserialize this variant.

• #[serde(skip_serializing)]

  Never serialize this variant. Trying to serialize this variant is treated as an error.

• #[serde(skip_deserializing)]

  Never deserialize this variant.

• #[serde(serialize_with = "path")]

  Serialize this variant using a function that is different from its implementation of Serialize. The given function must be callable as fn<S>(&FIELD0, &FIELD1, ..., S) -> Result<S::Ok, S::Error> where S: Serializer, although it may also be generic over the FIELD{n} types. Variants used with serialize_with are not required to be able to derive Serialize.

  FIELD{n} exists for every field of the variant. So a unit variant has just the S argument, and tuple/struct variants have an argument for every field.

• #[serde(deserialize_with = "path")]

  Deserialize this variant using a function that is different from its implementation of Deserialize. The given function must be callable as fn<'de, D>(D) -> Result<FIELDS, D::Error> where D: Deserializer<'de>, although it may also be generic over the elements of FIELDS. Variants used with deserialize_with are not required be able to derive Deserialize.

  FIELDS is a tuple of all fields of the variant. A unit variant will have () as its FIELDS type.

• #[serde(with = "module")]

  Combination of serialize_with and deserialize_with. Serde will use $module::serialize as the serialize_with function and $module::deserialize as the deserialize_with function.

• #[serde(bound = "T: MyTrait")]

  Where-clause for the Serialize and/or Deserialize impls. This replaces any trait bounds inferred by Serde for the current variant.

  Allows specifying independent bounds for serialization vs deserialization:

  • #[serde(bound(serialize = "T: MySerTrait"))]
  • #[serde(bound(deserialize = "T: MyDeTrait"))]
  • #[serde(bound(serialize = "T: MySerTrait", deserialize = "T: MyDeTrait"))]

• #[serde(borrow)] and #[serde(borrow = "'a + 'b + ...")]

  Borrow data for this field from the deserializer by using zero-copy deserialization. See this example. Only allowed on a newtype variant (a tuple variant with only one field).

• #[serde(other)]

  Deserialize this variant if the enum tag is anything other than the tag of one of the other variants in this enum. Only allowed on a unit variant inside of an internally tagged or adjacently tagged enum.

  For example if we have an internally tagged enum with serde(tag = "variant") containing variants A, B, and Unknown marked serde(other), the Unknown variant would be deserialized any time the "variant" field of the input is neither "A" nor "B".

• #[serde(untagged)]

  Irrespective of the enum representation, serialize and deserialize this variant as untagged, i.e. simply as the variant's data with no record of the variant name.

  Untagged variants must be ordered last in the enum definition.