# 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:
<pre>
{{ = 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]"
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
</pre>
### Examples
```rust
#[macro_use] extern crate scan_fmt;
use std::error::Error ;
fn main() -> Result<(),Box<dyn Error>> {
let (a,b,c) = scan_fmt!( "hello 0x12 345 bye", // input string
"hello {x} {} {}", // format
[hex u8], i32, String) ? ; // type of a-c Options
assert_eq!( a, 0x12 ) ;
assert_eq!( b, 345 ) ;
assert_eq!( c, "bye" ) ;
println!("Enter something like: 123-22");
let (c,d) = scanln_fmt!( "{d}-{d}", // format
u16, u8) ? ; // type of a&b Options
println!("Got {} and {}",c,d) ;
// Note - currently scanln_fmt! just calls unwrap() on read_line()
let (a,b) = scan_fmt_some!( "hello 12 345", // input string
"hello {} {}", // format
u8, i32) ; // types
assert_eq!( a, Some(12) ) ;
assert_eq!( 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.