# dyn-future

This is a small crate implementing convenient and fast dynamic Futures in Rust.

The `DynFuture<T>` type this library provides is intended as a replacement
for the naive `Box<dyn Future<Output = T>>`.

## Usability

This library is designed to be dead simple to use and require no setup.
You can freely mix the naive boxed futures from dependencies and such without issue.

`DynFuture<T>` can be used the same way as `Box<dyn Future<Output = T>>`
and most of the time you can just run find and replace on your existing code.

`DynFuture<T>` can be awaited like any other future, but it has a fixed size.

It should only be used as a replacement for `Box<dyn Future<Output = T>>`.
If it is possible you should always prefer statically resolved futures using `async fn`.

## Compilation overhead

dyn-future strives to be small and to minimize dependencies.
If you have any questions or improvements to make, feel free to open an issue.

## Why?

The provided `DynFuture<T>` type is faster than the naive implementation.
Exactly how much depends on the global allocator, amount of CPU logical processors
and the sizes of the futures sent. Though in general `DynFuture<T>` is always faster.

Currently we provide some extremely simple benchmarks. These could absolutely be improved.
This is something I would like help with as I am not fantastic at writing benchmarks.

There are not representative of real world gains due to the lack of variation of future types.
I have done some minor benchmarking of a proprietary codebase using dyn-future
with over 8x gains in time spent handling dynamic futures.

## Contributing

dyn-future gladly accepts contributions!

Open a PR and I will take a look.