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

announcements
#1

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"
    }
}
2 Likes
Errors in Rust can now be handled more ergonomically, cleanly, and simply: introducing a new error crate
#2

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()? )
}