(values_of) cannot return value referencing local variable matches

[nbari]

From this example: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=4ff6b06028b40df40bf01cf1d2809135,

I want to use the matched arguments Vec<&str> but I get cannot return value referencing local variable matches when trying to use args[0]:

use clap::{App, Arg, SubCommand}; // 2.33.1

#[derive(Debug)]
enum Action<'a> {
    GET(Option<&'a str>),
}

fn main() {
    let a = options().unwrap();
    println!("{:#?}", a);
}

fn options<'a>() -> Result<Action<'a>, ()> {
    let home_dir = std::path::PathBuf::from("/tmp");
    let default_config = format!("{}/.s3m/config.yml", home_dir.display());
    let matches = App::new("test")
        .arg(
            Arg::with_name("config")
                .default_value(&default_config)
                .required(true)
                .value_name("config.yml"),
        )
        .subcommand(
            SubCommand::with_name("ls")
                .about("list objects")
                .arg(Arg::with_name("arguments").required(true).min_values(1)),
        )
        .get_matches();

    let args: Vec<&str> = if let Some(ls) = matches.subcommand_matches("ls").to_owned() {
        ls.values_of("arguments").unwrap_or_default().collect()
    } else {
        matches.values_of("arguments").unwrap_or_default().collect()
    };

    let dir = if args.is_empty() { None } else { Some(args[0]) };
    
    // this works with Some("foo")
    // let dir = if args.is_empty() { None } else { Some("foo") };

    Ok(Action::GET(dir))
}

How could I create the vector use so that I could use the collected values when returning?

[CreepySkeleton]

Short answer: matches is a local variable, value_of borrows from it and therefore the returned &str reference must not outlive matches, but you're trying to return the ref while matches will be dropped when execution reaches the end of the function, so the ref will become invalid. The solution is to return Vec<String> - no references, no problems (and a slight perf penalty you won't even notice).

Long answer: I think you have just yet to comprehend rust borrowing rules and lifetimes. See the book: https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#dangling-references

[nbari]

Hi @CreepySkeleton thanks for the link, I still trying to understand how to return a String or collect() without using unwrap but for example If I do something like:

   let args: Vec<String> = if let Some(ls) = matches.subcommand_matches("ls") {
        if let Some(a) = ls.values_of("arguments") {
             a.into_iter().collect()
        }
    } else {
        if let Some(a) = matches.values_of("arguments") {
            a.into_iter().collect()
        }
    };

I get errors like:

error[E0317]: `if` may be missing an `else` clause

or

: a value of type `std::vec::Vec<std::string::String>` cannot be built from an iterator over elements of type `&str`

Any hint about how could I use String but still handle properly the error (no unwrap)

[CreepySkeleton]

        if let Some(a) = ls.values_of("arguments") {
             a.into_iter().collect()
        }
        // where is else??? 
        else {
            vec![]
        }

Also, you don't need into_iter.

[CreepySkeleton]

And you also need to map:

        if let Some(a) = ls.values_of("arguments") {
             a.map(|v| v.to_string()).collect()
        }

[nbari]

Hi, I omitted the else "thinking" it will just discard the rest from and example found here https://doc.rust-lang.org/stable/rust-by-example/flow_control/if_let.html but I think I got it wrong.

Also even with the else still can't make it work: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=bc559b14a2731979a8a7f21796fa9a99 I am getting:

 a value of type `std::vec::Vec<std::string::String>` cannot be built from an iterator over elements of type `&str`

[CreepySkeleton]

And why don't you read the message?

a value of type std::vec::Vec<std::string::String> cannot be built from an iterator over elements of type &str

You need to turn &str into String somehow. See my comment above about mapping.

Actually, with this kind of newbie-level questions, you'd better go to users.rust-lang.org

[nbari]

Hi @CreepySkeleton thanks for the help, I am learning lifetimes and currently trying to return an enum or struct only with references, this is why in https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=4ff6b06028b40df40bf01cf1d2809135 I have the <'a> the reason and motivation for learning more about it is because I am using clippy and frequently when checking my code that uses custom validators they all need to return a String instead of an &str as suggested from the clippy output, example:

error: this argument is passed by value, but not consumed in the function body
  --> src/s3m/options.rs:39:15
   |
39 | fn is_file(s: String) -> Result<(), String> {
   |               ^^^^^^ help: consider changing the type to: `&str`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value

And when using &str:

error[E0631]: type mismatch in function arguments
   --> src/s3m/options.rs:102:28
    |
39  | fn is_file(s: &str) -> Result<(), String> {
    | ----------------------------------------- found signature of `for<'r> fn(&'r str) -> _`
...
102 |                 .validator(is_file),
    |                            ^^^^^^^ expected signature of `fn(std::string::String) -> _`

I agree that this could be something very basic &str/String or newbie-level as you mention but the context around makes things more complex, and in some cases even in other channels/sites is not easy to find the answers, but well, thanks again for your time and support 👍