derive_utils

A procedural macro helper for trait implemention for enums.

Usage

Add this to your Cargo.toml:

toml [dependencies] derive_utils = "0.3"

and this to your crate root:

rust extern crate derive_utils;

Examples

```rust extern crate deriveutils; extern crate procmacro; extern crate syn;

use deriveutils::{derivetrait, EnumData}; use proc_macro::TokenStream; use syn::DeriveInput;

[procmacroderive(Iterator)]

pub fn derive(input: TokenStream) -> TokenStream { let ast: DeriveInput = syn::parse(input).unwrap(); let data = EnumData::from_derive(&ast).unwrap();

derive_trait!(
    data,
    // path
    (Iterator),
    // trait
    trait Iterator {
        type Item;
        fn next(&mut self) -> Option<Self::Item>;
        fn size_hint(&self) -> (usize, Option<usize>);
    }
)
.unwrap()
.into()

} ```

Generated code

When deriving for enum like the following:

```rust

[derive(Iterator)]

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

Code like this will be generated:

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

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

See auto_enums crate for more examples.

Crate Features

• std
  • Enabled by default.
  • Generate code for std library.
  • Disable to generate code for no_std.

Rust Version

The current minimum required Rust version is 1.30.

License

Licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

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.