Crate derive_deftly

derive-deftly: An ergonomic replacement for many proc macros

[ docs: crate top-level | overall toc, macros | template etc. reference | guide/tutorial ]

derive-deftly allows you to write macros which are driven by Rust data structures, just like proc macro derive macros, but without having to wrestle with the proc macro system.

Overview

You can write an ad-hoc template, which can speak about the fields and types in the data structure. You can also define named templates and apply them to multiple structures: effectively, you can define your own derive macro.

You don’t need to make a separate proc macro crate, write to the syn and proc_macro APIs. take care to properly propagate compile errors, or, generally, do any of the things that make writing proc macros so complicated.

The template language resembles the “expander” part of a macro_rules macro, but you don’t have to write the “matcher” part: derive-deftly parses the input data structure for you, and makes the pieces available via predefined expansion variables.

Full documentation is available in the doc_ module(s), the docs for the individual proc macros, and the Guide.

Simple example - providing Vec containing enum variant names

use derive_deftly::{define_derive_deftly, Deftly};

define_derive_deftly! {
    ListVariants:

    impl $ttype {
        fn list_variants() -> Vec<&'static str> {
            vec![ $( stringify!( $vname ) , ) ]
        }
    }
}

#[derive(Deftly)]
#[derive_deftly(ListVariants)]
enum Enum {
    UnitVariant,
    StructVariant { a: u8, b: u16 },
    TupleVariant(u8, u16),
}

assert_eq!(
    Enum::list_variants(),
    ["UnitVariant", "StructVariant", "TupleVariant"],
);

Next steps

Why not have a look at our friendly user guide? It will walk you through derive-deftly’s most important features, with a number of worked examples.

Alternatively, there is comprehensive reference documentation.

derive-deftly documentation, overall table of contents

[ docs: crate top-level | overall toc, macros | template etc. reference | guide/tutorial ]

Guide

Tutorial and walkthrough, in book form

Modules

doc_changelog

Changelog, MSRV policy and cargo features

doc_implementation

Implementation approach - how does this work?

doc_reference

Template syntax (and expansion options) reference

Macros

define_derive_deftly

Define a reuseable template

derive_deftly_adhoc

Expand an ad-hoc template, on a data structure decorated #[derive_deftly_adhoc]

derive_deftly_engine

Template expansion engine, internal

template_export_semver_check

Check semver compatibility, for a crate which exports macros

Derive Macros

Deftly

Perform ad-hoc templating driven by a data structure