Is is possible to parse values into Cow<'source, str>?

[jeertmans]

Hi!

I have some struct Cli that contains text. I don't want to store an owned version of the text, mainly because I only need a &str and requiring the user to provide owned String will eventually lead to unnecessary clones.

For convenience, I also derive clap::Parser this struct, such that it is possible to create it from command-line arguments.

Note

I guess this is a frequent issue, but I could not find any other post mentioning this.

In practice, my struct has many other fields, and creating two almost identical structures
just to have clap on the "owned" version, would required duplicating a lot of the code.
So I would prefer not having to duplicate code :-)

I know clap requires the parsed value to be 'static, but I thought it would be possible to handle both owned and borrowed variants using Cow, see my attempt below.

use clap::Parser;
use std::borrow::Cow;

// Error type is not important
fn parse_cow_str(string: &str) -> Result<Cow<'static, str>, std::io::Error>{
    Ok(Cow::Owned(string.to_owned()))
}

#[derive(Parser)]
pub struct Cli<'source> {
    #[arg(long, value_parser = clap::builder::ValueParser::new(parse_cow_str))]
    pub text: Cow<'source, str>,
}

fn main() {
    let manual_cli = Cli {
        text: "here is some text".into()
    };

    assert!(matches!(manual_cli.text, Cow::Borrowed(_)));

    let cli = Cli::parse();

    assert!(matches!(cli.text, Cow::Owned(_)));
}

Of course, this does not compile (see error traceback below), and I was wondering if there was a solution to this?

error: lifetime may not live long enough
  --> src/main.rs:12:15
   |
10 | pub struct Cli<'source> {
   |                ------- lifetime `'source` defined here
11 |     #[arg(long, value_parser = clap::builder::ValueParser::new(parse_cow_str))]
12 |     pub text: Cow<'source, str>,
   |               ^^^ requires that `'source` must outlive `'static`

[epage]

I guess this is a frequent issue, but I could not find any other post mentioning this.

In general, few CLI definitions get reused in other ways as a lot of what is useful for a CLI doesn't always apply in other situations

Of course, this does not compile (see error traceback below), and I was wondering if there was a solution to this?

My guess is that its because of

fn parse_cow_str(string: &str) -> Result<Cow<'static, str>, std::io::Error>{
    Ok(Cow::Owned(string.to_owned()))
}

That function says it could return a &'static str and then you try to store it in a &'source str.

You need to tell the compiler that you won't use the borrowed variant.

fn parse_cow_str<'ignored>(string: &str) -> Result<Cow<'ignored, str>, std::io::Error>{
    Ok(Cow::Owned(string.to_owned()))
}

If that doesn't compile, then you likely need a feature called higher ranked trait bounds (HRTB) to tell the compiler you don't care about that lifetime.

[jeertmans]

Thanks for your reply.

In general, few CLI definitions get reused in other ways as a lot of what is useful for a CLI doesn't always apply in other situations

You need to tell the compiler that you won't use the borrowed variant.

fn parse_cow_str<'ignored>(string: &str) -> Result<Cow<'ignored, str>, std::io::Error>{
    Ok(Cow::Owned(string.to_owned()))
}

That doesn't compile, either.

If that doesn't compile, then you likely need a feature called higher ranked trait bounds (HRTB) to tell the compiler you don't care about that lifetime.

Do you any hint or recommendations of how to start? I looked at https://doc.rust-lang.org/nomicon/hrtb.html, but I am not sure how this applies to my issue.

[epage]

Hmm, looks like 'static was the more correct route to go as clap will need to store it with a static lifetime.

The problem is instead in this generated code

impl<'source> clap::FromArgMatches for Cli<'source> {
...
        let v = Cli {
            text: __clap_arg_matches
                .remove_one::<Cow<'source, str>>("text")
                .ok_or_else(|| {
                    clap::Error::raw(
                        clap::error::ErrorKind::MissingRequiredArgument,
                        "The following required argument was not provided: text",
                    )
                })?,
        };

I found it by running cargo expand and then building that file instead (fixing some internal details)

clap should only impl for 'static and should use remove_one::<Cow<'static, str>> but it doesn't know that,.

[jeertmans]

Wouldn't it be possible for clap to automatically implement a parse trait P for Cow<'_, T> if T::Owned: P (not sure about the syntax)?

[epage]

clap could make it so parse_cow_str isn't needed anymore but the more fundamental problem is the code the proc-macro is generating. It could be updated to handle lifetimes. You are welcome to create an issue for it. However, it is unlikely to be a priority of mine for implementing.

[jeertmans]

Ok! I will create an issue so it's open for contribution. I am myself not sure to have the time nor the skills to implement this in the near future, but we'll see :-)