Dynamize

In order for a trait to be usable as a trait object it needs to fulfill several requirements. For example:

```rust trait Client { type Error;

fn get(&self, url: String) -> Result<Vec<u8>, Self::Error>;

}

impl Client for HttpClient { type Error = HttpError; ...} impl Client for FtpClient { type Error = FtpError; ...}

let client: HttpClient = ...; let object = &client as &dyn Client; ```

The last line of the above code fails to compile with:

error[E0191]: the value of the associated type Error (from trait Client) must be specified

Sometimes you however want a trait object to be able to encompass trait implementations with different associated type values. This crate provides an attribute macro to achieve that. To use dynamize you only have to make some small changes:

```rust

[dynamize::dynamize]

trait Client { type Error: Into;

fn get(&self, url: String) -> Result<Vec<u8>, Self::Error>;

}

let client: HttpClient = ...; let object = &client as &dyn DynClient; ```

You add the #[dynamize::dynamize] attribute to your trait.
You specify an Into<T> bound for each associated type.

Dynamize defines a new trait for you, named after your trait but with the Dyn prefix, so e.g. Client becomes DynClient in our example. The new "dynamized" trait can then be used without having to specify the associated type.

How does this work?

For the above example dynamize generates the following code:

```rust trait DynClient { fn get(&self, url: String) -> Result, SuperError>; }

impl<__to_be_dynamized: Client> DynClient for _tobedynamized { fn get(&self, url: String) -> Result, SuperError> { Client::get(self, url).maperr(|x| x.into()) } } ```

As you can see in the dynamized trait the associated type was replaced with the destination type of the Into bound. The magic however happens afterwards: dynamize generates a blanket implementation: each type implementing Client automatically also implements DynClient!

How does this actually work?

Dynamize recognizes the Result<T, E> in the return type and knows that associated types in T need to be mapped with map() whereas associated types in E need to be mapped with map_err(). Dynamize also understands Option<T>. Thanks to recursion Dynamize can deal with arbitrarily nested options and results, so e.g. Result<Option<Self::Item>, Self::Error> also just works.

The destination type of an associated type is determined by looking at its first trait bound:

Into<T> is mapped to T
SomeTrait is mapped to Box<dyn SomeTrait>
(for this SomeTrait of course needs to be object-safe)

Dynamize supports async

Dynamize supports async out of the box. Since Rust however does not yet support async functions in traits, you'll have to additionally use another library like async-trait, for example:

```rust

[dynamize::dynamize]

[dyntraitattr(async_trait)]

[blanketimplattr(async_trait)]

[async_trait]

trait Client: Sync { type Error: std::error::Error;

async fn get(&self, url: String) -> Result<Vec<u8>, Self::Error>;

} ```

The #[dyn_trait_attr(...)] attribute lets you attach macro attributes to the generated dynamized trait. The #[blanket_impl_attr(...)] attribute lets you attach macro attributes to the generated blanket implementation. Note that it is important that the dynamize attribute comes before the async_trait attribute.

Dynamize supports Fn, FnOnce & FnMut

The following also just works:

```rust

[dynamize::dynamize]

trait TraitWithCallback { type A: SomeTrait;

fn fun_with_callback<F: Fn(Self::A)>(&self, a: F);

} ```

Note that since in order to be object-safe methods must not have generics, dynamize simply moves the generic from the method to the trait definition.

If two method type parameters have the same name, dynamize enforces that they also have the same bounds and only adds the parameter once to the trait.