futures-rs | Zero-cost asynchronous programming in Rust | Reactive Programming library

I want to use the async function to parse the inbound stream progressively, but actix-web requires impl Future as the return value.

How can I convert the future returned by async function to what actix-web requires?

I'm using Rust 1.39 nightly and actix-web 1.0.7.

http_srv.rs :

There is an async connect() function as below.

I'm writing a future combinator that needs to consume a value that it was provided with. With futures 0.1, Future::poll took self: &mut Self, which effectively meant that my combinator contained an Option and I called Option::take on it when the underlying future resolves.

The Future::poll method in the standard library takes self: Pin<&mut Self> instead, so I've been reading about the guarantees required in order to safely make use of Pin.

From the pin module documentation on the Drop guarantee (emphasis mine):

Concretely, for pinned data you have to maintain the invariant that its memory will not get invalidated from the moment it gets pinned until when drop is called. Memory can be invalidated by deallocation, but also by replacing a Some(v) by None, or calling Vec::set_len to "kill" some elements off of a vector.

And Projections and Structural Pinning (emphasis mine):

You must not offer any other operations that could lead to data being moved out of the fields when your type is pinned. For example, if the wrapper contains an Option and there is a take-like operation with type fn(Pin<&mut Wrapper>) -> Option, that operation can be used to move a T out of a pinned Wrapper -- which means pinning cannot be structural.

However, the existing Map combinator calls Option::take on a member value when the underlying future has resolved:

I am using a futures-rs powered version of the Rusoto AWS Kinesis library. I need to spawn a deep pipeline of AWS Kinesis requests to achieve high-throughput because Kinesis has a limit of 500 records per HTTP request. Combined with the 50ms latency of sending a request, I need to start generating many concurrent requests. I am looking to create somewhere on the order of 100 in-flight requests.

The Rusoto put_records function signature looks like this:

Using the futures-rs library, I've encountered a situation where a stream needs to be mapped through an indeterminate number of other streams before being returned to the user. Since the exact type of the output stream is unknown at the end of this operation, I've been using a BoxStream trait object while storing the stream in a struct and when returning it.

Although this approach works fine, it has the unfortunate side effect of causing the inner Stream object to be unsized. This is a problem because every one of the stream combinators require Self: Sized in their signatures meaning that I can't even wait() on the returned BoxStream in order to convert it into a blocking iterator.

Here's an example of a situation that could lead to this issue: