derive_utils

API Documentation

A procedural macro helper for trait implemention for enums.

Usage

Add this to your Cargo.toml:

toml [dependencies] derive_utils = "0.1"

and this to your crate root:

```rust

[macro_use]

extern crate derive_utils; ```

Examples

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

use deriveutils::EnumData; use procmacro::TokenStream; use quote::quote; 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();

let path = syn::parse_str("Iterator").unwrap();
let trait_ = syn::parse2(quote! {
    trait Iterator {
        type Item;
        fn next(&mut self) -> Option<Self::Item>;
        fn size_hint(&self) -> (usize, Option<usize>);
    }
}).unwrap();

data.make_impl_trait(path, None, trait_)
    .unwrap()
    .build()
    .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(), } } } ```

• 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.