inpt 0.1.1

A derive crate for dumb type-level text parsing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# Inpt

Inpt is a derive crate for dumb type-level text parsing.

Read the [lastest documentation](https://samsartor.gitlab.io/inpt/inpt/index.html) for more information.

## Introduction
Imagine you need to chop up an annoying string and convert all the bits to useful types.
You could write that sort of code by hand using `split` and `from_str`, but the boiler-plate
of unwrapping and checking quickly looses all charm. Especially since that sort of parsing
shows up a lot in timed programming competitions like [advent of code](https://adventofcode.com).

Inpt tries to write that sort of parsing code for you, automatically splitting input strings
based on field types and an optional regex. Inpt is absolutely _not_ performant, strict, or formal.
Whenever possible, it does the obvious thing:
<div style="display: flex; flex-direction: row; align-items: stretch; gap: 1em">

```rust
#[inpt::main]
fn main(x: f32, y: f32) {
    println!("{}", x * y);
}
```

```text
$ echo '6,7' | cargo run
42
```

</div>

## Example
```rust
use inpt::{Inpt, inpt};

#[derive(Inpt)]
#[inpt(regex = r"(.)=([-\d]+)\.\.([-\d]+),?")]
struct Axis {
    name: char,
    start: i32,
    end: i32,
}

#[derive(Inpt)]
#[inpt(regex = "target area:")]
struct Target {
    #[inpt(after)]
    axes: Vec<Axis>,
}

impl Target {
    fn area(&self) -> i32 {
        self.axes.iter().map(|Axis { start, end, ..}| end - start).product()
    }
}


let target = inpt::<Target>("target area: x=119..176, y=-114..84").unwrap();
assert_eq!(target.area(), 11286);
```