scan_fmt

scan_fmt provides a simple scanf()-like input for Rust. The goal is to make it easier to read data from a string or stdin.

Currently the format string supports the following special sequences:

   {{ = escape for '{'
   }} = escape for '}'
   {} = return any value (until next whitespace)
   {d} = return base-10 decimal
   {x} = return hex (0xab or ab)
   {f} = return float
   {*d} = "*" as the first character means "match but don't return"
   {2d} or {2x} or {2f} = limit the maximum width to 2.  Any positive integer works.
   {[...]} = return pattern.
     ^ inverts if it is the first character
     - is for ranges.  For a literal - put it at the start or end.
     To add a literal ] do "[]abc]"
   {e} = doesn't return a value, but matches end of line.  Use this if you
         don't want to ignore potential extra characters at end of input.
   Examples:
     {[0-9ab]} = match 0-9 or a or b
     {[^,.]} = match anything but , or .
   {/.../} = return regex inside of `//`.
     If there is a single capture group inside of the slashes then
     that group will make up the pattern.
   Examples:
     {/[0-9ab]/} = same as {[0-9ab]}, above
     {/a+/} = matches at least one `a`, greedily
     {/jj(a*)jj/} = matches any number of `a`s, but only if
       they're surrounded by two `j`s

Examples

```rust #[macrouse] extern crate scanfmt; use std::error::Error ; fn main() -> Result<(),Box> { let (a,b,c) = scanfmt!( "hello 0x12 345 bye", // input string "hello {x} {} {}", // format [hex u8], i32, String) ? ; // type of a-c Options asserteq!( a, 0x12 ) ; asserteq!( b, 345 ) ; asserteq!( c, "bye" ) ;

println!("Enter something like: 123-22"); let (c,d) = scanlnfmt!( "{d}-{d}", // format u16, u8) ? ; // type of a&b Options println!("Got {} and {}",c,d) ; // Note - currently scanlnfmt! just calls unwrap() on read_line()

let (a,b) = scanfmtsome!( "hello 12 345", // input string "hello {} {}", // format u8, i32) ; // types asserteq!( a, Some(12) ) ; asserteq!( b, Some(345) ) ; Ok(()) } ```

Limitations

There is no compile-time warning if the number of {}'s in the format string doesn't match the number of return values. You'll just get None for extra return values. See src/lib.rs for more details.