auto_enums

A library for to allow multiple return types by automatically generated enum.

This library provides the following attribute macros:

• #[auto_enum]

  Parses syntax, creates the enum, inserts variants, and passes specified traits to #[enum_derive].

• #[enum_derive]

  Implements specified traits to the enum.

Usage

Add this to your Cargo.toml:

toml [dependencies] auto_enums = "0.3"

and this to your crate root:

```rust

[macro_use]

extern crate auto_enums; ```

Examples

#[auto_enum]'s basic feature is to wrap the value returned by the last if or match expression by an enum that implemented the specified traits.

```rust

[auto_enum(Iterator)]

fn foo(x: i32) -> impl Iterator { match x { 0 => 1..10, _ => vec![5, 10].into_iter(), } } ```

#[auto_enum] generates code in two stages.

First, #[auto_enum] will do the following.

• parses syntax
• creates the enum
• inserts variants

Code like this will be generated:

```rust fn foo(x: i32) -> impl Iterator { #[enumderive(Iterator)] enum Enum1<__T1, __T2> { _T1(T1), T2(T2), }

match x {
    0 => __Enum1::__T1(1..10),
    _ => __Enum1::__T2(vec![5, 10].into_iter()),
}

} ```

Next, #[enum_derive] implements the specified traits.

Code like this will be generated

See API Documentation for more details.

Supported traits

#[enum_derive] implements the supported traits and passes unsupported traits to #[derive].

If you want to use traits that are not supported by #[enum_derive], you can use another crate that provides proc_macro_derive, or you can define proc_macro_derive yourself ([derive_utils] probably can help it).

Basic usage of #[enum_derive]

``rust //#[enum_derive]implementsIterator, and#[derive]implementsClone`.

[enum_derive(Iterator, Clone)]

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

[std|core] libraries

Note that some traits have aliases.

[std|core]::ops

• Deref
• DerefMut
• Index
• IndexMut
• Fn (nightly-only)
• FnMut (nightly-only)
• FnOnce (nightly-only)
• RangeBounds

[std|core]::convert

• AsRef
• AsMut

[std|core]::iter

• Iterator
• DoubleEndedIterator
• ExactSizeIterator
• FusedIterator
• TrustedLen (nightly-only)
• Extend

[std|core]::fmt

• Debug (alias: fmt::Debug) - generated code
• Display (alias: fmt::Display)
• fmt::Binary (requires "fmt" crate feature)
• fmt::LowerExp (requires "fmt" crate feature)
• fmt::LowerHex (requires "fmt" crate feature)
• fmt::Octal (requires "fmt" crate feature)
• fmt::Pointer (requires "fmt" crate feature)
• fmt::UpperExp (requires "fmt" crate feature)
• fmt::UpperHex (requires "fmt" crate feature)
• fmt::Write

[std|core]::future

• Future - nightly-only

std::io

• Read (alias: io::Read)
• BufRead (alias: io::BufRead)
• Write (alias: io::Write)
• Seek (alias: io::Seek)

std::error

• Error - generated code

External libraries

You can add support for external library by activating the each crate feature.

futures(v0.3) (requires "futures" crate feature)

• futures::Stream
• futures::Sink
• futures::AsyncRead
• futures::AsyncWrite

futures(v0.1) (requires "futures01" crate feature)

• futures01::Future
• futures01::Stream
• futures01::Sink

quote (requires "proc_macro" crate feature)

• quote::ToTokens

rayon (requires "rayon" crate feature)

• rayon::ParallelIterator
• rayon::IndexedParallelIterator
• rayon::ParallelExtend

serde (requires "serde" crate feature)

• serde::Serialize - generated code

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.