diff --git a/serde_with/src/lib.rs b/serde_with/src/lib.rs index 98fa4288..28252a0d 100644 --- a/serde_with/src/lib.rs +++ b/serde_with/src/lib.rs @@ -37,14 +37,14 @@ //! Some common use cases are: //! //! * De/Serializing a type using the `Display` and `FromStr` traits, e.g., for `u8`, `url::Url`, or `mime::Mime`. -//! Check [`DisplayFromStr`] for details. +//! Check [`DisplayFromStr`] for details. //! * Support for arrays larger than 32 elements or using const generics. -//! With `serde_as` large arrays are supported, even if they are nested in other types. -//! `[bool; 64]`, `Option<[u8; M]>`, and `Box<[[u8; 64]; N]>` are all supported, as [this examples shows](#large-and-const-generic-arrays). +//! With `serde_as` large arrays are supported, even if they are nested in other types. +//! `[bool; 64]`, `Option<[u8; M]>`, and `Box<[[u8; 64]; N]>` are all supported, as [this examples shows](#large-and-const-generic-arrays). //! * Skip serializing all empty `Option` types with [`#[skip_serializing_none]`][skip_serializing_none]. //! * Apply a prefix / suffix to each field name of a struct, without changing the de/serialize implementations of the struct using [`with_prefix!`][] / [`with_suffix!`][]. //! * Deserialize a comma separated list like `#hash,#tags,#are,#great` into a `Vec`. -//! Check the documentation for [`serde_with::StringWithSeparator::`][StringWithSeparator]. +//! Check the documentation for [`serde_with::StringWithSeparator::`][StringWithSeparator]. //! //! ## Getting Help //! diff --git a/serde_with/src/rust.rs b/serde_with/src/rust.rs index 71fb394f..bae825e3 100644 --- a/serde_with/src/rust.rs +++ b/serde_with/src/rust.rs @@ -620,7 +620,7 @@ pub mod maps_first_key_wins { /// /// 1. It is useful for instance to create an enum with a catch-all variant that will accept any incoming data. /// 2. [`untagged`] enum representations do not allow the `other` annotation as the fallback enum variant. -/// With this function you can emulate an `other` variant, which can deserialize any data carrying enum. +/// With this function you can emulate an `other` variant, which can deserialize any data carrying enum. /// /// **Note:** Using this function will prevent deserializing data-less enum variants. /// If this is a problem depends on the data format. diff --git a/serde_with/src/serde_conv.rs b/serde_with/src/serde_conv.rs index e93ef79a..d732d427 100644 --- a/serde_with/src/serde_conv.rs +++ b/serde_with/src/serde_conv.rs @@ -7,12 +7,12 @@ /// The macro takes four arguments: /// /// 1. The name of the converter type. -/// The type can be prefixed with a visibility modifies like `pub` or `pub(crate)`. -/// By default, the type is not marked as public (`pub(self)`). +/// The type can be prefixed with a visibility modifies like `pub` or `pub(crate)`. +/// By default, the type is not marked as public (`pub(self)`). /// 2. The type `T` we want to extend with custom behavior. /// 3. A function or macro taking a `&T` and returning a serializable type. /// 4. A function or macro taking a deserializable type and returning a `Result`. -/// The error type `E` must implement [`Display`]. +/// The error type `E` must implement [`Display`]. /// /// [`Display`]: std::fmt::Display /// diff --git a/serde_with_macros/src/lib.rs b/serde_with_macros/src/lib.rs index cd05f0f3..0d3940de 100644 --- a/serde_with_macros/src/lib.rs +++ b/serde_with_macros/src/lib.rs @@ -130,10 +130,7 @@ where .iter_mut() .map(|field| function(field).map_err(|err| err.with_span(&field))) // turn the Err variant into the Some, such that we only collect errors - .filter_map(|res| match res { - Err(e) => Some(e), - Ok(()) => None, - }) + .filter_map(std::result::Result::err) .collect(); if errors.is_empty() { Ok(()) @@ -147,10 +144,7 @@ where .iter_mut() .map(|field| function(field).map_err(|err| err.with_span(&field))) // turn the Err variant into the Some, such that we only collect errors - .filter_map(|res| match res { - Err(e) => Some(e), - Ok(()) => None, - }) + .filter_map(std::result::Result::err) .collect(); if errors.is_empty() { Ok(()) @@ -199,10 +193,7 @@ where .iter_mut() .map(|variant| apply_on_fields(&mut variant.fields, function)) // turn the Err variant into the Some, such that we only collect errors - .filter_map(|res| match res { - Err(e) => Some(e), - Ok(()) => None, - }), + .filter_map(std::result::Result::err), ); if errors.is_empty() { @@ -517,53 +508,53 @@ fn field_has_attribute(field: &Field, namespace: &str, name: &str) -> bool { /// ``` /// /// 1. All the placeholder type `_` will be replaced with `::serde_with::Same`. -/// The placeholder type `_` marks all the places where the type's `Serialize` implementation -/// should be used. In the example, it means that the `u32` values will serialize with the -/// `Serialize` implementation of `u32`. The `Same` type implements `SerializeAs` whenever the -/// underlying type implements `Serialize` and is used to make the two traits compatible. +/// The placeholder type `_` marks all the places where the type's `Serialize` implementation +/// should be used. In the example, it means that the `u32` values will serialize with the +/// `Serialize` implementation of `u32`. The `Same` type implements `SerializeAs` whenever the +/// underlying type implements `Serialize` and is used to make the two traits compatible. /// -/// If you specify a custom path for `serde_with` via the `crate` attribute, the path to the -/// `Same` type will be altered accordingly. +/// If you specify a custom path for `serde_with` via the `crate` attribute, the path to the +/// `Same` type will be altered accordingly. /// /// 2. Wrap the type from the annotation inside a `::serde_with::As`. -/// In the above example we now have something like `::serde_with::As::>`. -/// The `As` type acts as the opposite of the `Same` type. -/// It allows using a `SerializeAs` type whenever a `Serialize` is required. +/// In the above example we now have something like `::serde_with::As::>`. +/// The `As` type acts as the opposite of the `Same` type. +/// It allows using a `SerializeAs` type whenever a `Serialize` is required. /// /// 3. Translate the `*as` attributes into the serde equivalent ones. -/// `#[serde_as(as = ...)]` will become `#[serde(with = ...)]`. -/// Similarly, `serialize_as` is translated to `serialize_with`. +/// `#[serde_as(as = ...)]` will become `#[serde(with = ...)]`. +/// Similarly, `serialize_as` is translated to `serialize_with`. /// -/// The field attributes will be kept on the struct/enum such that other macros can use them -/// too. +/// The field attributes will be kept on the struct/enum such that other macros can use them +/// too. /// /// 4. It searches `#[serde_as(as = ...)]` if there is a type named `BorrowCow` under any path. -/// If `BorrowCow` is found, the attribute `#[serde(borrow)]` is added to the field. -/// If `#[serde(borrow)]` or `#[serde(borrow = "...")]` is already present, this step will be -/// skipped. +/// If `BorrowCow` is found, the attribute `#[serde(borrow)]` is added to the field. +/// If `#[serde(borrow)]` or `#[serde(borrow = "...")]` is already present, this step will be +/// skipped. /// /// 5. Restore the ability of accepting missing fields if both the field and the transformation are `Option`. /// -/// An `Option` is detected by an exact text match. -/// Renaming an import or type aliases can cause confusion here. -/// The following variants are supported. -/// * `Option` -/// * `std::option::Option`, with or without leading `::` -/// * `core::option::Option`, with or without leading `::` +/// An `Option` is detected by an exact text match. +/// Renaming an import or type aliases can cause confusion here. +/// The following variants are supported. +/// * `Option` +/// * `std::option::Option`, with or without leading `::` +/// * `core::option::Option`, with or without leading `::` /// -/// If the field is of type `Option` and the attribute `#[serde_as(as = "Option")]` (also -/// `deserialize_as`; for any `T`/`S`) then `#[serde(default)]` is applied to the field. +/// If the field is of type `Option` and the attribute `#[serde_as(as = "Option")]` (also +/// `deserialize_as`; for any `T`/`S`) then `#[serde(default)]` is applied to the field. /// -/// This restores the ability of accepting missing fields, which otherwise often leads to confusing [serde_with#185](https://github.com/jonasbb/serde_with/issues/185). -/// `#[serde(default)]` is not applied, if it already exists. -/// It only triggers if both field and transformation are `Option`s. -/// For example, using `#[serde_as(as = "NoneAsEmptyString")]` on `Option` will not see -/// any change. +/// This restores the ability of accepting missing fields, which otherwise often leads to confusing [serde_with#185](https://github.com/jonasbb/serde_with/issues/185). +/// `#[serde(default)]` is not applied, if it already exists. +/// It only triggers if both field and transformation are `Option`s. +/// For example, using `#[serde_as(as = "NoneAsEmptyString")]` on `Option` will not see +/// any change. /// -/// If the automatically applied attribute is undesired, the behavior can be suppressed by adding -/// `#[serde_as(no_default)]`. +/// If the automatically applied attribute is undesired, the behavior can be suppressed by adding +/// `#[serde_as(no_default)]`. /// -/// This can be combined like `#[serde_as(as = "Option", no_default)]`. +/// This can be combined like `#[serde_as(as = "Option", no_default)]`. /// /// After all these steps, the code snippet will have transformed into roughly this. /// @@ -1017,11 +1008,11 @@ fn has_type_embedded(type_: &Type, embedded_type: &syn::Ident) -> bool { /// or enum. Currently, these arguments to the attribute are possible: /// /// * **`#[serde_with(crate = "...")]`**: This allows using `DeserializeFromStr` when `serde_with` -/// is not available from the crate root. This happens while [renaming dependencies in -/// Cargo.toml][cargo-toml-rename] or when re-exporting the macro from a different crate. +/// is not available from the crate root. This happens while [renaming dependencies in +/// Cargo.toml][cargo-toml-rename] or when re-exporting the macro from a different crate. /// -/// This argument is analogue to [serde's crate argument][serde-crate] and the [crate argument -/// to `serde_as`][serde-as-crate]. +/// This argument is analogue to [serde's crate argument][serde-crate] and the [crate argument +/// to `serde_as`][serde-as-crate]. /// /// # Example /// @@ -1151,11 +1142,11 @@ fn deserialize_fromstr(mut input: DeriveInput, serde_with_crate_path: Path) -> T /// or enum. Currently, these arguments to the attribute are possible: /// /// * **`#[serde_with(crate = "...")]`**: This allows using `SerializeDisplay` when `serde_with` is -/// not available from the crate root. This happens while [renaming dependencies in -/// Cargo.toml][cargo-toml-rename] or when re-exporting the macro from a different crate. +/// not available from the crate root. This happens while [renaming dependencies in +/// Cargo.toml][cargo-toml-rename] or when re-exporting the macro from a different crate. /// -/// This argument is analogue to [serde's crate argument][serde-crate] and the [crate argument -/// to `serde_as`][serde-as-crate]. +/// This argument is analogue to [serde's crate argument][serde-crate] and the [crate argument +/// to `serde_as`][serde-as-crate]. /// /// # Example ///