Chained commands and many positional args?

[abey79]

I'm trying to build on the chained command example and add support for a command with variable number of positional args:

use bpaf::Bpaf;

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(external(cmd), many)]
    pub commands: Vec<Cmd>,
}

#[derive(Debug, Clone, Bpaf)]
pub enum Cmd {
    #[bpaf(command, adjacent)]
    Layer {
        #[bpaf(positional("LID"))]
        id: Vec<isize>,
    },
    #[bpaf(command, adjacent)]
    Print,
}

fn main() {
    println!("{:?}", options().run())
}

I'm expecting to be able to parse something like layer 1 2 3 print. However this, fails with the following error:

Error: couldn't parse print: invalid digit found in string

layer appears to be eagerly trying to parse print as additional id value and fails instead of stopping.

Is there a way to make this pattern work?

I guess the workaround would be to use a syntax like layer 1,2,3 print, which is not quite as nice, and also doesn't allow layer print (to get an empty id vector).

[abey79]

Trying the workaround suggested by the many_comma_separated_args_derive.rs, I can't make it work with positional args either:

/// To parse comma separated values it's easier to treat them as strings
use bpaf::*;
use std::{num::ParseIntError, str::FromStr};

fn split_and_parse(s: String) -> Result<Vec<u16>, ParseIntError> {
    s.split(',')
        .map(u16::from_str)
        .collect::<Result<Vec<_>, _>>()
}

fn flatten_vec(vv: Vec<Vec<u16>>) -> Vec<u16> {
    vv.into_iter().flatten().collect()
}

#[derive(Debug, Clone, Bpaf)]
#[allow(dead_code)]
struct Opts {
    #[bpaf(positional("PORTS"), parse(split_and_parse), many, map(flatten_vec))]
    /// Comma separated list of ports
    ports: Vec<u16>,
}

fn main() {
    println!("{:?}", opts().to_options().run());
}

This fails to compile.

[abey79]

Actually, I could find a workaround using external:

use bpaf::*;
use std::{ str::FromStr};

fn ports() -> impl Parser<Vec<u16>> {
    positional::<String>("PORTS")
        .parse(|s| {
            s.split(',')
                .map(u16::from_str)
                .collect::<Result<Vec<_>, _>>()
        })
        .many()
        .map(|nested| nested.into_iter().flatten().collect())
}

#[derive(Debug, Clone, Bpaf)]
#[allow(dead_code)]
struct Opts {
    #[bpaf(external)]
    /// Comma separated list of ports
    ports: Vec<u16>,
}

fn main() {
    println!("{:?}", opts().to_options().run());
}

[pacak]

        #[bpaf(positional("LID"))]
        id: Vec<isize>,

I'm expecting to be able to parse something like layer 1 2 3 print. However this, fails with the following error:

Error: couldn't parse print: invalid digit found in string

For that parser for ids need to be able to recover from parsing failure. having something like #[bpaf(positional("LID"), many, catch)] might help.

https://docs.rs/bpaf/0.9.11/bpaf/parsers/struct.ParseMany.html#method.catch

[abey79]

This works, thanks a lot!

use bpaf::Bpaf;

// all these are valid:
// layer print
// layer 1 print
// layer 1 2 3 print
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(external(cmd), many)]
    pub commands: Vec<Cmd>,
}

#[derive(Debug, Clone, Bpaf)]
pub enum Cmd {
    #[bpaf(command, adjacent)]
    Layer {
        #[bpaf(positional("LID"), many, catch)]
        id: Vec<isize>,
    },
    #[bpaf(command, adjacent)]
    Print,
}

fn main() {
    println!("{:?}", options().run())
}