Trouble using DisplayFromStr on an Option<T> field.

[Krapaince]

Hello,
I'm trying to Serialize this structure:

use serde::Serialize;
use serde_with::{serde_as, skip_serializing_none, DisplayFromStr};

pub enum Section {
  Authentication,
}

pub enum Documentation { // Use the `Display` trait of its variant to implement its own `Display` trait.
  Section(Section), // Implements Display
  Tag(Tag), // Enum like Section, Implements Display
  Operation(Operation), // Enum Like Section Implements Display
}

#[skip_serializing_none]
#[serde_as]
#[derive(Serialize)]
pub struct ApiErrorModel {
  error: ErrorCode,
  error_description: Option<String>,
  
  #[serde_as(as = "DisplayFromStr")]
  error_uri: Option<Documentation>
}

Cargo output:

error[E0277]: `std::option::Option<Documentation>` doesn't implement `std::fmt::Display`
   --> src/domains/common/models/routes/responses/error.rs:11:1
    |
11  | / #[serde_as]
12  | | #[derive(Serialize)]
    | |_________________________^ `std::option::Option<Documentation>` cannot be formatted with the default formatter
    | 
   ::: /home/krapaince/.cargo/registry/src/github.com-1ecc6299db9ec823/serde_with-1.9.4/src/lib.rs:360:12
    |
360 |           T: SerializeAs<I>,
    |              -------------- required by this bound in `As::<T>::serialize`
    |
    = help: the trait `std::fmt::Display` is not implemented for `std::option::Option<Documentation>`
    = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
    = note: required because of the requirements on the impl of `SerializeAs<std::option::Option<Documentation>>` for `DisplayFromStr`
    = note: this error originates in the attribute macro `serde_as` (in Nightly builds, run with -Z macro-backtrace for more info)

But this requires the implementation of the Display trait for Option<Documentation which I can't implement and don't want to since the field is skipped because of skip_serializing_none.

Does there is a way to do it with serde_with?
I already try to:

• Add the field attribute #[skip_serializing_if = "Option::is_none"] to error_uri
• Inverse the order of #[skip_serializing_none] and #[serde_as]

Or do I have to implement the Serialize trait for ApiErrorModel?

[jonasbb]

If your Documentation implements Display, then you write this. If you need Deserialize you also want to add #[serde(default)], otherwise the field will not be optional while deserializing. This issue #185 has the details.

    #[serde_as(as = "Option<DisplayFromStr>")]
    error_uri: Option<Documentation>,

Writing #[serde_as(as = "Option<DisplayFromStr>")] means there is a Option<T> where T: Display. If you write #[serde_as(as = "DisplayFromStr")] it requires your field to be Display, here Option<Documentation>: Display, but Option never implements Display, so this will not work.

In general, the idea of serde_as is that you attribute mirrors the structure of your type, but you place a modifier (like DisplayFromStr) whenever you need a different serialization behavior.

Rust Type				serde_as Annotation

Option <				Option <
    Documentation			DisplayFromStr
>						>

---

An alternative is to use SerializeDisplay as a derive on Documentation. This also requires that Documentation implements Display. This will derive Serialize for Documentation, such that you can serialize it everywhere without any further serde_as annotations.

#[derive(serde_with::SerializeDisplay)]
pub enum Documentation { ... }

[Krapaince]

Oh, I see, I was missing the wrapper part of serde_as, I should have RTFM, sorry. Got it to working. Thank you.

If anyone is searching for an answer:

use serde::Serialize;
use serde_with::{serde_as, skip_serializing_none, DisplayFromStr};

pub enum Section {
  Authentication,
}

pub enum Documentation { // Use the `Display` trait of its variant to implement its own `Display` trait.
  Section(Section), // Implements Display
  Tag(Tag), // Enum like Section, Implements Display
  Operation(Operation), // Enum Like Section Implements Display
}

#[skip_serializing_none]
#[serde_as]
#[derive(Serialize)]
pub struct ApiErrorModel {
  error: ErrorCode,
  error_description: Option<String>,
  
  #[serde_as(as = "DisplayFromStr")]
  error_uri: Option<Documentation>
}

[jonasbb]

@Krapaince I'm happy to help. Glad you got it working. I am not sure if the part about wrapper types in serde_as annotations is quite so well documented in the manual.

[Krapaince]

I looked through the documentation of serde_with and the only thing that I found missing, for me, is some cross-reference.

For example, for serde_as there is the default documentation page that I rushed into (using the search bar) when I needed documentation for it.
And then there is the guide part of the documentation which is well written, full of useful examples (even contains the example that I needed to solve my case) but unexpected and I haven't had look into it until now.

Given that, I think that adding some links to lead back to the guide should be sufficient.