[enumx 0.4.1] enum trait delegation and `-> impl Trait`

[oooutlk]

Documentation

See the enumx book for more.

What's new

1. macros for enum trait implementation delegated to its variants.
   Provides _Variants!(),_Variant!(),_variant!(),_match!(),_enum!() inside def_impls!{}.

   def_impls! {
       impl<T0,T1> Clone for Enum2<T0,T1>
           where _Variants!(): Clone
       {
           fn clone( &self ) -> Self {
               _match!(
                   _enum!( _variant!().clone() )
               )
           }
       }
   }
   

   Predefined impls for frequently used std traits:

   impl_trait!{ Iterator _for!( Type )}
   

   Note: User defined enums are also supported.

2. Allows functions returning -> impl Trait to return different types as long as they implemented the trait.

   #[sum]
   fn f( cond: bool ) -> impl Clone {
       if cond {
           #[variant] 1_i32
       } else {
           #[variant] "false"
       }
   }
   

[oooutlk]

And one more thing: checked exception as impl Error.

Sometimes the downstream users do not bother "poluting" signatures of functions
which call upstream #[cex] APIs returning checked exceptions. If all variants
of the error Enum!() have implemented some famous trait, e.g.
std::error::Error, the downstream users get a chance to simply write
-> Result<_, impl std::error::Error> in their function signatures.

Example

use std::error::Error;
use enumx::export::*;
use enumx::predefined::*;
use cex::*;

impl Error for A { /* omitted */ }
impl Error for B { /* omitted */ }
impl Error for C { /* omitted */ }

#[cex] pub fn upstream() -> Result!( () throws A, B, C );

fn downstream() -> Result<(), impl Error> {
    Ok( upstream()? )
}