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.70 and above.}

Examples

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.

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.

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 trait yourself for fully custom parsing such as hexadecimal number parsing.

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 });

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