4 releases

0.1.5 Mar 20, 2021
0.1.4 Mar 4, 2021
0.1.3 Dec 8, 2020
0.1.2 Oct 11, 2020

#250 in Procedural macros

Download history 7670/week @ 2022-10-12 9041/week @ 2022-10-19 8195/week @ 2022-10-26 8795/week @ 2022-11-02 6391/week @ 2022-11-09 6570/week @ 2022-11-16 6336/week @ 2022-11-23 6394/week @ 2022-11-30 7285/week @ 2022-12-07 8853/week @ 2022-12-14 4068/week @ 2022-12-21 3612/week @ 2022-12-28 7096/week @ 2023-01-04 9835/week @ 2023-01-11 10852/week @ 2023-01-18 16529/week @ 2023-01-25

45,433 downloads per month
Used in 33 crates (13 directly)

MIT/Apache

50KB
944 lines

crates.io docs.rs

derive-syn-parse: A derive macro for syn's Parse trait

This is a fairly straightforward derive macro that produces an implementation syn::parse::Parse for the type it's applied to.

A common pattern when writing custom syn parsers is repeating <name>: input.parse()? for each field in the output. This crate's #[derive(Parse)] handles that for you, with some helpful extra customization.

Usage

Using this crate is as simple as adding it to your 'Cargo.toml' and importing the derive macro:

# Cargo.toml

[dependencies]
derive-syn-parse = "0.1.5"
// your_file.rs
use derive_syn_parse::Parse;

#[derive(Parse)]
struct CustomParsable {
    // ...
}

The derived implementation of Parse will always parse in the order that the fields are given. Detailed information about the various field attributes available is given in the crate documentation.

This crate is primarily intended for users who are already making heavy use of syn and wish to reduce the amount of boilerplate code required.

Motivation

When writing rust code that makes heavy use of syn's parsing functionality, we often end up writing things like:

use syn::parse::{Parse, ParseStream};
use syn::{Ident, Token, Type};

// A simplified struct field
//
//     x: i32
struct MyField {
    ident: Ident,
    colon_token: Token![:],
    ty: Type,
}

impl Parse for MyField {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(MyField {
            ident: input.parse()?,
            colon_token: input.parse()?,
            ty: input.parse()?,
        })
    }
}

This is really repetitive! Ideally, we'd like to just #[derive(Parse)] and have it work. And so we can! (for the most part) Adding #[derive(Parse)] to the previous struct produces an equivalent implementation of Parse:

use syn::{Ident, Token, Type};
use derive_syn_parse::Parse;

#[derive(Parse)]
struct MyField {
    ident: Ident,
    colon_token: Token![:],
    ty: Type,
}

Of course, there are more complicated cases. But - even though they're complicated, many of them are still covered by the various advanced features provided! For more information, see the crate documentation.

Dependencies

~195–590KB
~14K SLoC