Here is what a remote derive implementation looks like, a lot of hassle and hackery:

[derive(Serialize, Deserialize)]
#[serde(remote = "clap_verbosity_flag::Verbosity")]
struct VerbosityDef {
    #[serde(getter = "clap_verbosity_flag::Verbosity::verbose")]
    pub verbose: u8,
    #[serde(getter = "clap_verbosity_flag::Verbosity::quiet")]
    pub quiet: u8,
}

pub trait VerbosityRemoteGetters {
    fn verbose(&self) -> u8;
    fn quiet(&self) -> u8;
}

impl VerbosityRemoteGetters for clap_verbosity_flag::Verbosity {
    fn verbose(&self) -> u8 {
        let debug_string = format!("{:#?}", self);
        let re = Regex::new(r"verbose: (?<verbose>[\d]+)").unwrap();
        let output = re.captures(&debug_string).unwrap();
        let string_value = output.name("verbose").unwrap().as_str();
        let calc = string_value.parse::<u8>().unwrap();
        calc
    }
    fn quiet(&self) -> u8 {
        let debug_string = format!("{:#?}", self);
        let re = Regex::new(r"quiet: (?<quiet>[\d]+)").unwrap();
        let output = re.captures(&debug_string).unwrap();
        let string_value = output.name("quiet").unwrap().as_str();
        let calc = string_value.parse::<u8>().unwrap();
        calc
    }
}

impl From<VerbosityDef> for clap_verbosity_flag::Verbosity {
    fn from(def: VerbosityDef) -> clap_verbosity_flag::Verbosity {
        clap_verbosity_flag::Verbosity::new(def.verbose, def.quiet)
    }
}

#[derive(Serialize, Deserialize, Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    #[serde(with = "VerbosityDef")]
    #[command(flatten)]
    verbose: clap_verbosity_flag::Verbosity,
}

Or, I could just copy/paste out the core of the implementation in fewer lines:

To be clear, are those your use cases or theoretical use cases?

As for the serialization format, I consider any non-textual serialization format to be a non-starter. As a user, entering random numbers in two fields and dealing with how those fields interact makes no sense and I would expect to just say "trace" or similar. The CLI is designed for user convenience / following convention and we hide the individual fields because that is the level of abstraction people should be working with.

I have both of those use cases in the project I'm working on. You're looking at a trimmed down main.rs from a project that I'm just starting in on.

https://www.wispbuild.com

Designing a query for particular nodes in a huge DAG is hard; it's way easier to present them to the user for clicking/visual feedback of what is selected. They can run multiple times from the GUI context until it is right, and then serialize out the command string for later use.

Sample output for each option in the GUI makes it easy to figure out which options are in use, and applies to both verbose and quiet.

I don't have super-strong opinions here (I've since dropped this as a dep), but I feel like there is a lot of value in standardizing the underlying tooling layer for the CLI hello world because it creates consistent UX outcomes for users.

The lack of Serialize and Deserialize caused me to eject from that vision.

Not exposing the numerics means that displaying the outcome as a range slider in the HTML GUI still requires mapping it myself from string, making the i16 approach more attractive. But that's not super-materially different since I need the labels anyway. (The web UI would never be two fields, the actual serialization format remains an implementation detail not presented to the end-user.)

I just ran into an actual non theoretical use for where Serialize and Deserialize are useful.

I'm implementing a cli app that can be configured by either clap or loaded from a config file using Figment. This approach is documented at https://docs.rs/figment/latest/figment/#for-cli-application-authors

To load the config / cli args, I have a config struct:

#[derive(Debug, Deserialize, Serialize, Parser)]
pub struct Config {
    /// The port to listen on
    #[arg(short, long, default_value = "3000")]
    pub port: u16,

    /// The default log level
    #[command(flatten)
    pub log_level: Verbosity<InfoLevel>,
}

and a load function:

pub fn load() -> Result<Config> {
    Figment::from(Serialized::defaults(Config::parse()))
        .merge(Toml::file("Config.toml"))
        .extract()
        .wrap_err("Failed to load configuration")
}

This parses the args into a config, serializes the config, and merges these values with any values set in the config file (likely these should be around the other way - config then cli, but the serialization part is the blocker here regardless.)

Would implementing this as a serialization onto the level name be sufficient to move this forward?

@joshka to clarify, what you are looking for is the names of the levels to be serialized?

@joshka to clarify, what you are looking for is the names of the levels to be serialized?

Yes, I phrased it poorly, but what I meant to ask was given that you "consider any non-textual serialization format to be a non-starter.", would a PR that (de)serializes Verbosity<InfoLevel> into a string representation of the log level name ("trace", "debug", etc.) be worth investing time into?

@joshka the use cases for that kind of solution are much clearer, as demonstrated by the one you listed. If its behind a serde feature, I'm good with it.

#114 works to adopt words for the serialization format.

It started by delegating to LogLevels serde support but there wasn't a way to distinguish "off" from "unset" / "default".

We tried switching to LevelFilter but all values are serialized in SCREMAING_CASE (though snake_case is accepted for deserialization apparently). We are stuck between being consistent with LevelFilter and being consistent with the style of most serialized values.

We tried switching to LevelFilter but all values are serialized in SCREMAING_CASE (though snake_case is accepted for deserialization apparently). We are stuck between being consistent with LevelFilter and being consistent with the style of most serialized values.

I think this is a reasonable tradeoff to make rather than manually implementing serialize. My thinking is that it's consistent with how log::Level or log::LevelFilter would be serialized if that was directly used instead of the verbosity flag being interjected. It's a two way door if that's a wrong assumption, as it's compatible to change the serialization format in the future, so long as deserialization still works.

I'm also fine with changing this to lowercase, but I'm 90/10 that uppercase is the right choice though.