async-std | Async version of the Rust standard library | Reactive Programming library

Every time your Person future is polled, you create a brand new fn1 future:

You need to pin:

Trying to be generic over the Executor trait is a bit overkill. You should probably just use a pool of size 1 in your test and manually callBegin and ROLLBACK.

The direct answer to your question is to use the FutureExt::now_or_never method from the futures crate as in stream.next().now_or_never().

However it is important to avoid writing a busy loop that waits on several things by calling now_or_never on each thing in a loop. This is bad because it is blocking the thread, and you should prefer a different solution such as tokio::select! to wait for multiple things. For the special case of this where you are constantly checking whether the task should shut down, see this other question instead.

On the other hand, an example where using now_or_never is perfectly fine is when you want to empty a queue for the items available now so you can batch process them in some manner. This is fine because the now_or_never loop will stop spinning as soon as it has emptied the queue.

Beware that if the stream is empty, then now_or_never will succeed because next() immediately returns None in this case.

This works because TcpStream has the following impls:

In v0.99.10 you can use to_path_buf().

You need to enable the unstable feature:

The problem came from the security features of Firefox.
Firefox detects that the certificate is not signed by an authority and sends back an error.
It seems like adding the certificate to the known authorities does not work.

To avoid this issue, I found this thread which indicates that an exception should be added for the address and port of your development Websocket server.

Go to Settings > Certificates > View Certificates > Servers > Add Exception...
Type in your local server (for me localhost:8020).
Add exception.

A function returning a trait can use the impl Trait syntax to return an opaque type that implements the trait. A trait method returning a trait currently doesn't support this feature and requires the trait to be returned as a trait object - a dynamically dispatched reference or smart pointer such as Box or Rc. Not all traits are object-safe, though, and the bad news is that StreamExt is among those that aren't, for reasons pointed out by the compiler, such as referencing Self in method return types and where clauses.

The good news, however, is that this is not a problem: StreamExt is an extension trait, one that provides a blanket implementation for all types that implement Stream. So you don't need to bother returning a dyn StreamExt trait object, you can return a dyn Stream one, and you'll still get access to StreamExt methods simply by requesting them with use StreamExt. In other words, you can just replace Box with Box in the return type of your trait.

Another issue you might encounter is that Box doesn't work on methods that need to move the stream, which includes many methods provided by StreamExt. Those will require the stream to be pinned, which can be fixed by returning Pin> instead of Box. There is even a boxed() method on StreamExt that pins and boxes the stream in one operation; code that uses it would look like this (playground):