auto_enums

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

This crate is a procedural macro implementation of the features discussions in [rust-lang/rfcs#2414]. This idea is also known as "Anonymous sum types".

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

Compiler support: requires rustc 1.31+

Examples

#[auto_enum]'s basic feature is to wrap the value returned by the obvious branches (match, if, return, etc..) by an enum that implemented the specified traits.

```rust use autoenums::autoenum;

[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 { #[::autoenums::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

#[auto_enum] can also parse nested arms/branches by using the #[nested] attribute.

```rust use autoenums::autoenum;

[auto_enum(Iterator)]

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

See documentation for more details.

Supported traits

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

#[enum_derive] supports many of the standard library traits and some popular third-party libraries traits such as [rayon], futures, tokio. See documentation for a complete list of supported traits.

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

Basic usage of #[enum_derive]

```rust use autoenums::enumderive;

// #[enum_derive] implements Iterator, and #[derive] implements Clone.

[enum_derive(Iterator, Clone)]

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

Optional features

• std (enabled by default)
  • Enable to use std library's traits.
• ops
  • Enable to use [std|core]::ops's Deref, DerefMut, Index, IndexMut, and RangeBounds traits.
• convert
  • Enable to use [std|core]::convert's AsRef and AsMut traits.
• fmt
  • Enable to use [std|core]::fmt's traits other than Debug, Display and Write.
• transpose_methods
  • Enable to use transpose* methods.
• futures03
  • Enable to use futures v0.3 traits.
• futures01
  • Enable to use futures v0.1 traits.
• rayon
  • Enable to use [rayon] traits.
• serde
  • Enable to use [serde] traits.
• tokio1
  • Enable to use tokio v1 traits.
• tokio03
  • Enable to use tokio v0.3 traits.
• tokio02
  • Enable to use tokio v0.2 traits.
• tokio01
  • Enable to use tokio v0.1 traits.
• generator_trait
  • Enable to use [std|core]::ops::Generator trait.
  • Note that this feature is unstable and may cause incompatible changes between patch versions.
• fn_traits
  • Enable to use [std|core]::ops's Fn, FnMut, and FnOnce traits.
  • Note that this feature is unstable and may cause incompatible changes between patch versions.
• trusted_len
  • Enable to use [std|core]::iter::TrustedLen trait.
  • Note that this feature is unstable and may cause incompatible changes between patch versions.

type_analysis feature

Analyze return type of function and let binding.

Note that this feature is still experimental.

Examples:

```rust use autoenums::autoenum;

[auto_enum] // there is no need to specify std library's traits

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

[auto_enum]

fn func2(x: i32) { // Unlike feature(impl_trait_in_bindings), this works on stable compilers. #[autoenum] let _iter: impl Iterator = match x { 0 => Some(0).intoiter(), _ => 0..x, }; } ```

Please be careful if you return another traits with the same name.

Related Projects

• [derive_utils]: A procedural macro helper for easily writing derives macros for enums.
• [futures-enum]: #[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums.
• [io-enum]: #[derive(Read, Write, Seek, BufRead)] for enums.
• [iter-enum]: #[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums.

License

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.