# ltnt
`ltnt` is a command-line arguments parsing library. It's a simple, efficient,
and flexible library. See the documentation for full examples, as well as the
`/examples` directory.
### Simple
It uses a powerful, but easy, syntax for establishing the structure of your
invocation:
```rust
ltnt::ltnt! {
// A set of commands
pub enum Root in RootArgs {
~Help, // A default command without arguments
Ls = Ls, // A command with arguments
};
// A set of arguments
#[derive(Debug)]
pub struct Ls {
// An argument with long and short forms and a default value
pub all('a'): bool = false,
// An optional argument that's been renamed
pub in_dir as "in" ?: String,
};
}
```
### Efficient
It uses a declarative macro, has only one dependency, and avoids unnecessary
allocations. It's also available on `no_std` (with `no-default-features`),
though it still requires `alloc`.
### Flexible
Most of the enforced structure in `ltnt` is merely in how the macro implements
the core trait (`Parsable`) for your types. So long as you can implement
`Parsable`, you can use any types you want. The only hard requirements are that
your type is `Sized`, and that it can be parsed from a stream of strings with
only one item of lookahead.
In practice, you'll usually be interacting with three "kinds" of parsables:
commands, arguments, and values.
## Roadmap and non-goals
In the future, I'd like to add a system for generating documentation from your
structure, especially help text. I'd also like to support e.g. completion
generators, but I don't intend to write them myself.
I also don't plan to support arbitrary syntaxes, or a builder. The reason for
the latter is because builders require some kind of enforced structure, which I
don't want to force on users. One could, however, implement one on top of `ltnt`
- that would be awesome!
