It would be better to just go look at real CLI utilities and see what they do instead of trying to use something like this IMO. This project seems to just be throwing everything against the wall. It's likely you won't need most of it. For example, this template uses twice as many dependencies as ripgrep.

Rust is quite feature rich and perfectly usable without any of these.

Some people are a bit trigger happy when adding dependencies, without considering the extra cost in maintenance and security.

There may be alternatives, but a new person might be wondering "how do I generate a random number in Rust" and not want to roll their own RNG or find another library.

And that's not to say you have to use any of those in any particular project, just that they are the main options for achieving their particular functionality.

I don't think it gets enough credit for being so pleasant to use.

The fact that there isn't a framework doesn't mean there's a problem. It could just be you have an unnatural need for structure where none is needed.

https://github.com/nemesiscodex/actix-todo

My advice is pick a http server that you want to use and search github for Cargo.lock

https://github.com/cookiecutter/cookiecutter

The extensions all have a lot of boilerplate so we use it as a replacement for a PHONY make target for niceties for the extension author like question prompts, enumerated lists for selecting, etc.

[EDIT: Also snafu, hello there Shepmaster :P ]

It works well for libraries and applications and has bells and whistles you might want, such as backtrace captures on stable Rust.

You can see what the libraries do by expanding the procedural macros they use. When you look at the output, it's nothing special that you couldn't have done yourself!

See https://rust-starter.github.io/#feature-errors for why Failure is still used.

1. Is there an example application that uses the starter?

2. Does it follow the command line interface guidelines at https://clig.dev?

2. First time I this. There are things that relate to Clap and things (like configuration) that could be implemented in rust-starter.

[0]: https://github.com/iqlusioninc/abscissa

[0] https://doc.rust-lang.org/std/env/fn.args.html

[1] https://github.com/TeXitoi/structopt

0: https://github.com/clap-rs/clap

[0] https://github.com/joyent/statemap/blob/rust/src/main.rs#L95

[1] https://github.com/joyent/statemap/pull/41

What clap gives you is something more like Python's argparse, which offers things like convenient parsing, automatically generated manpages and error/usage messages, etc.

https://github.com/ablakey/gameboy/blob/master/src/main.rs#L...

(I'm sure people will shout that this isn't the right way to parse optional flags)

Since that sounds like a challenge, just wanted to make sure that people are aware of Iterator::nth (https://doc.rust-lang.org/std/iter/trait.Iterator.html#metho...), which means you can entirely replace lines 8 and 9 with `let cartridge_path = env::args().nth(1);` :) In combination with Iterator::any to replace line 10, you can avoid a whopping five whole heap allocations this way!! :P

I feel like when I'm done I need to find a bit of cash and get a veteran to code review the whole thing. I'm learning a ton by suffering through it myself. But also probably missing a lot of great shortcuts and tips.

I assume the "five heap allocations" is kinda tongue in cheek? My understanding is that while it is good to avoid heap allocations, given this is a called-once piece of code, it's not really a big deal?

Indeed. :) I can't envision a circumstance where avoiding exactly five small allocations outside of any loop would be observable in either time or memory usage. As a Rust programmer it simply provides a warm and fuzzy feeling to avoid allocations in places where it not only doesn't obscure the code, but actually makes it shorter. At best, this could be a small step towards running your code on embedded hardware (which isn't unreasonable for an emulator like this), but only if you were to also eliminate all other allocations within your program.

Maybe I'm wrong but isn't the stack only a few MB in max size?

Appreciate your earlier comments. Thanks.

With Rust you will soon see that most applications require some sort of dependency like serde for serialization, etc.

   #[derive(StructOpt)]
   struct Opt {
       #[structopt(short, long)]
       debug: bool,
    
       #[structopt(short = "c", long)]
       nb_cars: Option<i32>,
    
       #[structopt(short, long)]
       level: Vec<String>,
   }