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.

^{Prse currently supports rustc 1.59 and above.}

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;

// 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.

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

let input = "cd C:\windows\system32"; let path: Result = 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. ```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, "{} + {}");

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

License

^{Licensed under either of Apache License, Version
2.0 or MIT license at your option.}

_{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.}