derive_utils

Build Status version documentation license Rustc Version

A procedural macro helper for easily writing [custom derives] for enums.

Usage

Add this to your Cargo.toml:

toml [dependencies] derive_utils = "0.8"

The current derive_utils requires Rust 1.31 or later.

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 extern crate proc_macro;

use deriveutils::quickderive; use proc_macro::TokenStream;

[procmacroderive(Iterator)]

pub fn deriveiterator(input: TokenStream) -> TokenStream { quickderive! { input, // trait 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, // super trait's associated types Item, // trait trait ExactSizeIterator: Iterator { fn len(&self) -> usize; } } }

[procmacroderive(FusedIterator)]

pub fn derivefusediterator(input: TokenStream) -> TokenStream { quick_derive! { input, // super trait's associated types Item, // path (std::iter::FusedIterator), // trait trait FusedIterator: Iterator {}, } }

[procmacroderive(Future)]

pub fn derivefuture(input: TokenStream) -> TokenStream { quickderive! { input, // path (std::future::Future), // trait trait Future { type Output; fn poll(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll; } } } ```

Generated code

When deriving for enum like the following:

```rust

[derive(Iterator, ExactSizeIterator, FusedIterator, Future)]

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

Code like this will be generated:

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

impl Iterator for Enum where A: Iterator, B: 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(), } } }

impl ExactSizeIterator for Enum where A: ExactSizeIterator, B: ExactSizeIterator::Item>, { fn len(&self) -> usize { match self { Enum::A(x) => x.len(), Enum::B(x) => x.len(), } } }

impl std::iter::FusedIterator for Enum where A: std::iter::FusedIterator, B: std::iter::FusedIterator::Item>, { }

impl std::future::Future for Enum where A: std::future::Future, B: std::future::Future::Output>, { type Output = ::Output;

fn poll(
    self: std::pin::Pin<&mut Self>,
    cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Self::Output> {
    unsafe {
        match self.get_unchecked_mut() {
            Enum::A(x) => std::pin::Pin::new_unchecked(x).poll(cx),
            Enum::B(x) => std::pin::Pin::new_unchecked(x).poll(cx),
        }
    }
}

} ```

License

Licensed under either of

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.