afmt

Simple rust library for parsing basic data structures from strings.

Usage

You can specify string formats to any strucute, via the use of the fmt macro, in which you can specify a chain of string literals and struct member names, to represent the format of a structure.

#[fmt("value: " v "--" f)]
struct Foo {
    v: u32,
    r: f64,
}

let f: Foo = "value: 65--3.14".parse()?;

Limitations

Consider we want to parse strings similar to

some text here 364

into a struct with a String first part and a u32 second part.

If we tried parsing it as the following format attribute

#[fmt(msg v)]
struct Foo {
    msg: String,
    v: u32,
}

the result would be ambiguous, multiple interpretations could be

Foo {
    msg: "some text here ",
    v: 364,
}
Foo {
    msg: "some text here 3",
    v: 64,
}
Foo {
    msg: "some text here 36",
    v: 4,
}
            ...

this means that we must specify some literal delimiter between every pair of capture variables. Literal delimiters are parsed in a way that the first match splits the string, so a delimiter of " " would result in the two parts beign "some" and "text here 364", which is not ideal.

For this reason, you should consider which strings you can easily parse, by considering special delimiters, i.e. delimiters should not appear in data you want to capture.

Examples

#[macro_use] extern crate afmt;

#[fmt("value :" v)]
struct Foo {
    v: u32,
}

#[test]
fn it_works() {
    let f: Foo = "value: 65".parse().unwrap();
    assert_eq!(f.v, 65);
}

#[fmt("x[" x "] y[" y "]")]
struct Point {
    x: u32,
    y: u32,
}

#[test]
fn it_works() {
    let p: Point = "x[65] y[39]".parse().unwrap();
    assert_eq!(p.x, 65);
    assert_eq!(p.y, 39);
}

= "WARN: this is a warning".parse(); assert!(b.is_err()); } ">

#[fmt("INFO: " msg)]
struct Bar {
    msg: String,
}

#[test]
fn it_works() {
    let b: Result<Bar,_> = "WARN: this is a warning".parse();
    assert!(b.is_err());
}

Comments

Rename fmt to parse

I was very confused in the first place, that afmt::fmt actually is meant for parsing. When I first saw fmt I thought it would implement std::fmt::Display and I thought, hey! That's neat!

But only after looking at the sources (and reading the doc 🙃) I saw it's actually meant for parsing a string into a struct.

Maybe consider renaming the struct? Next step would be to have a fmt macro that implements std::fmt::Display? Because that would be sick as well!

opened by hellow554 1
use Format strings instead
Currently your Syntax is

#[fmt("..." V "...")]

And for me this is so confusing, because you have to open, close, open, close, open, .... The string a lot!

My proposal is that you should be able to use Format strings, e.g.

"... {}...{}...{}", x, y, z

Or inspired by Python

"...{x}...{y}...{z}"

What do you think?
opened by hellow554 0