# 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.