The dep on envy is unnecessary, and its error variants don't particularly make sense for here.
Instead, I would expect something like:

enum Error {
    RegexDoesNotMatchInputString,
    DeserializationError{ ... }
}

💡 Feature description

Currently the code generated by #[derive(Recap)] doesn't seem to be able to be composed in any manner. Ideally, I would more or less expect that fields of types with #[derive(Recap)] ought to be able to be parsed just like primitives and builtin types.

💻 Basic example

#[derive(Debug, Deserialize, Recap)]
#[recap(regex = r#"(?P<quantity>\d+) (?P<name>\w+)"#)]
struct Chemical {
    quantity: u32,
    name: String,
}

#[derive(Debug, Deserialize, Recap)]
#[recap(regex = r#"(?P<inner>\d+ \w+)"#)]
struct Wrapper {
    inner: Chemical,
}

fn main() {
    // ok
    "1 FUEL".parse::<Chemical>().unwrap();

    // Err(Custom("invalid type: string "1 FUEL", expected struct Chemical"))
    "1 FUEL".parse::<Wrapper>().unwrap();
}

I tried to write something like this

💻 Basic example

use recap::Recap;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize, Recap)]
#[recap(regex = r#"(?x)
    (?P<foo>\d+)
    \s+
    (?P<bar>true|false)
    \s+
    (?P<baz>\S+)
  "#)]
struct LogEntry {
    foo: usize,
    bar: bool,
    baz: Option<String>,
}

fn main() -> Result<(), Box<dyn Error>> {
    let logs = r#"1 true  
    2 false world"#;

    for line in logs.lines() {
        let entry: LogEntry = line.parse()?;
        println!("{:#?}", entry);
    }

    Ok(())
}

Error: Custom("No captures resolved in string '1 true '")

I'm learning Rust and this library is extremely useful for quick parsing of string data. However I've been stuck trying to parse a value which should be an enum; something like these strings:

R ff0000
G 00ff00
B 0000ff

My code looks like this:

use recap::Recap;
use serde::Deserialize;

#[derive(Deserialize, Recap)]
#[recap(regex = r#"(?P<dir>\w) (?P<code>\w+)"#)]
struct Config {
    type: Color,
    code: String,
}

#[derive(Debug, Deserialize)]
enum Color {
    R,
    G,
    B,
}

I have even tried with a FromStr implementation, but I'm really blindly trying things because of being too new to the ecosystem and not being able to figure out what direction I should take:

impl FromStr for Color {
    type Err = ();
    fn from_str(s: &str) -> Result<Color, ()> {
        match s {
            "R" => Ok(Color::R),
            "G" => Ok(Color::G),
            "B" => Ok(Color::B),
            _ => Err(()),
        }
    }
}

What I'd request is to extend the documentation if recap can be used for this use case; and otherwise a comment about it, so future beginners don't spend too much time trying to make it work, like me :-)

I am getting the following error for the basic example. What am I doing wrong?

this type alias takes 1 generic argument but 2 generic arguments were supplied, expected 1 generic argument

10 | #[derive(Debug, Deserialize, Recap)]
   |                              ^^^^^
   |                              |
   |                              expected 1 generic argument
   |                              help: remove this generic argument
   |

👟 Steps to reproduce

#[derive(Debug, Deserialize, Recap)]
#[recap(regex = r#"(?x)
    (?P<foo>\d+)  
    \s+ 
    (?P<bar>true|false)
    \s+
    (?P<baz>\S+) 
  "#)]
struct LogEntry {
    foo: usize,
    bar: bool,
    baz: String,
}

🌍 Your environment

Rust (Windows) 1.67.1

recap version:
0.1.2

Per cargo book: https://doc.rust-lang.org/nightly/cargo/reference/manifest.html#the-homepage-field

💡 Feature description

the current design was an mvp with the error being an alias for envy::Error. This has the drawback in that its not currently possible in to destructure a type alias of an enum on stable rust. lets just create a custom error that has good From impls

💻 Basic example

This would enable amortizing allocations around building Captures.
https://docs.rs/regex/latest/regex/struct.CaptureLocations.html

💡 Feature description

It would be nice to be able to capture referenced data, like a more general Deserialize<'de> rather than just DeserializeOwned.

I realize that FromStr can't borrow data, since there's no lifetime parameter to use in relation to Self, but maybe there could be a trait Recap<'s> which does permit borrowing. I would think recap::from_captures could just use a 'de parameter for D: Deserialize<'de>.

💻 Basic example

I tried to write something like this for Advent of Code 2015 day 9:

#[derive(Deserialize, Recap)]
#[recap(regex = r"(?P<a>\w+) to (?P<b>\w+) = (?P<distance>\d+)")]
struct Distance<'a> {
    a: &'a str,
    b: &'a str,
    distance: u32,
}

error: implementation of `_IMPL_DESERIALIZE_FOR_Distance::_serde::Deserialize` is not general enough
[...]
   = note: `Distance<'_>` must implement `_IMPL_DESERIALIZE_FOR_Distance::_serde::Deserialize<'0>`, for any lifetime `'0`
   = note: but `Distance<'_>` actually implements `_IMPL_DESERIALIZE_FOR_Distance::_serde::Deserialize<'1>`, for some specific lifetime `'1`

It's not a big deal to use String instead in this case, since there aren't very many inputs overall, but it seems like a borrowed &str should be possible.

💡 Feature description

we have 90+% test automated coverage for the core lib but 0 for proc macro. let's see if we can increase that

💻 Basic example

potentially https://github.com/laumann/compiletest-rs

💡 Feature description

Compile regex at derive time and verify capture count matches field count of struct

💻 Basic example