Prse
==================
[<img alt="github" src="https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/miam-miam100/prse)
[<img alt="crates.io" src="https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust" height="20">](https://crates.io/crates/prse)
[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64, " height="20">](https://docs.rs/prse)

Prse is a small string parsing library with an emphasis on speed and ease of use. (It's also no-std compatible!)

It provides the [`parse!`] macro which allows you to easily parse strings into any type using a format args like syntax.

<sup>Prse currently supports rustc 1.61 and above.</sup>

[`parse!`]: https://docs.rs/prse/latest/prse/macro.parse.html

## Examples

```rust
use prse::parse;

let input = "5 + -2 = 3";

let total: i32;
let (lhs, rhs): (i32, i32) = parse!(input, "{} + {} = {total}");

assert_eq!(lhs + rhs, total);
```

It also allows you to parse into multiple variables separated by a separator in a single go.

```rust
use prse::parse;

let input = "My farm contains some amount of booleans: true || false || true || false";
let many: Vec<bool>;

// the variable to store the answer in is many and the separator is equal to " || "
parse!(input, "My farm contains some amount of booleans: {many: || :}");

assert_eq!(many, vec![true, false, true, false]);
```

You can use the [`try_parse!`] macro if you don't want to panic when the parsing fails.

[`try_parse!`]: https://docs.rs/prse/latest/prse/macro.try_parse.html

```rust
use prse::try_parse;
use std::path::PathBuf;

let input = "cd C:\\windows\\system32";
let path: Result<PathBuf, _> = try_parse!(input, "cd {}");

assert_eq!(path.unwrap(), PathBuf::from("C:\\windows\\system32"));
```

Additionally you can use the [`Parse`] derive macro to help you parse custom types. 
For even more flexibility you can implement the [`Parse`](https://docs.rs/prse/latest/prse/trait.Parse.html)
trait yourself for fully custom parsing such as hexadecimal number parsing.
```rust
use prse::{parse, Parse};

#[derive(Parse, PartialEq, Eq, Debug)]
#[prse = "({x}, {y})"]
struct Position { 
    x: i32, 
    y: i32,
}

let input = "(1, 3) + (-2, 9)";

let (lhs, rhs): (Position, Position) = parse!(input, "{} + {}");

assert_eq!(lhs, Position {x: 1, y: 3});
assert_eq!(rhs, Position {x: -2, y: 9});
```

[`Parse`]: https://docs.rs/prse/latest/prse/derive.Parse.html

#### License

<sup>
Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
</sup>

<br>

<sub>
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.
</sub>