#[static_dispatch::dispatch]
trait ExampleBehavior {
    fn as_value(self);
    fn as_ref(&self) {}
    fn as_mut(&mut self) {}
    async fn async_fn(&self) {}
    fn generic<T>(&self, value: T) {}
    fn impl_arg(&self, value: impl Into<i32>) {}
}

struct A;
impl ExampleBehavior for A {
    fn as_value(self) {}
    // ...
}

struct B;
impl ExampleBehavior for B {
    fn as_value(self) {}
    // ...
}

#[static_dispatch::dispatch(ExampleBehavior)]
enum Example {
    A(A),
    B(B),
}

async fn example() {
    for mut value in [
        Example::A(A),
        Example::B(B),
    ] {
        value.as_mut();
        value.as_ref();
        value.async_fn().await;
        value.generic(0);
        value.generic(Some(0));
        value.impl_arg(0i16);
        value.impl_arg(0i32);
        value.as_value();
    }
}

#[static_dispatch::dispatch]
trait SomethingBehavior<V> {
    fn something(&self, value: V);
}

struct A<'a>(&'a i32);

impl<'a, V> SomethingBehavior<V> for A<'a> {
    fn something(&self, _value: V) {}
}

struct B<T>(T);
impl<T, V> SomethingBehavior<V> for B<T> {
    fn something(&self, _value: V) {}
}

#[static_dispatch::dispatch(impl<'a, T, V> SomethingBehavior<V> for Something<'a, T>)]
enum Something<'a, T> {
    A(A<'a>),
    B(B<T>),
}

#[test]
fn generic_example() {
    let mut something = Something::A(A(&0));
    something.something();
    something = Something::B(B(0));
    something.something();
}