derive_utils

A procedural macro helper for easily writing derives macros for enums.

Usage

Add this to your Cargo.toml:

toml [dependencies] derive_utils = "0.12"

Compiler support: requires rustc 1.31+

Examples

[quick_derive!] macro make easy to write proc_macro_derive like deriving trait to enum so long as all variants are implemented that trait.

```rust use deriveutils::quickderive; use proc_macro::TokenStream;

[procmacroderive(Iterator)]

pub fn deriveiterator(input: TokenStream) -> TokenStream { quickderive! { input, // trait path std::iter::Iterator, // trait definition trait Iterator { type Item; fn next(&mut self) -> Option; fn size_hint(&self) -> (usize, Option); } } }

[procmacroderive(ExactSizeIterator)]

pub fn deriveexactsizeiterator(input: TokenStream) -> TokenStream { quickderive! { input, // trait path std::iter::ExactSizeIterator, // super trait's associated types , // trait definition trait ExactSizeIterator: Iterator { fn len(&self) -> usize; } } } ```

Generated code

When deriving for enum like the following:

```rust

[derive(Iterator, ExactSizeIterator, Future)]

enum Enum { A(A), B(B), } ```

Code like this will be generated:

```rust enum Enum { A(A), B(B), }

impl std::iter::Iterator for Enum where A: std::iter::Iterator, B: std::iter::Iterator::Item>, { type Item = ::Item; fn next(&mut self) -> Option { match self { Enum::A(x) => x.next(), Enum::B(x) => x.next(), } } fn sizehint(&self) -> (usize, Option) { match self { Enum::A(x) => x.sizehint(), Enum::B(x) => x.size_hint(), } } }

Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.