futures-rs VS thiserror

So this is actually better than true fairness (true fairness would lead to deadlock if a sender is forgotten). It is a pity that the there does not seem to be resources that document this design. There is this old thread where Carl provides some background, but I found it personally a bit hard to follow.

Is this still true after it switched to using FuturesOrdered?

Done.

You can use Streams, which are the async version of Iterators; They aren't stable yet, so you'll have to use a crate such as futures.

futures

For traits, like AsyncRead and AsyncWrite, go with the futures crate.

Here is the PR: https://github.com/rust-lang/futures-rs/pull/2551

Yield = wake the `waker_ref`. Avoiding the yield would be clone().wake().

That said, "poll immediately" isn't actually a thing nor was it ever a thing except in incorrect implementations.

Rust lacks an implementation of ReactiveX. futures/futures-signals seems to be the the ecosystem equivalent but I'm sure there'd be a lot of interest in an actual implementation.

The opposite problem exists as well. Many types are actually unwind safe, but do not get the autotrait. In that case authors would have to manually declare them UnwindSafe. Because this is rarely done, having an API with a trait bound T: UnwindSafe is rarely viable in terms of ergonomics. It now obliges client code to wrap all calls to your API in AssertUnwindSafe which, if they use types from third party libraries, obliges them to assert this is fine. example

Also, we plan to give users more control in the future. See https://github.com/rust-lang/futures-rs/issues/2207, https://github.com/rust-lang/futures-rs/issues/2295, etc. for this

We can utilize third-party libraries to simplify the code above. For example thiserror (https://github.com/dtolnay/thiserror) provides convenien derive macro for Error trait:

thiserror crate makes it easy to do so using macros on CliError enum.

Depending on your use case, thiserror and/or anyhow.

What is the benefit of splitting a proc-macro crate into (usually) two crates, proc_macro_crate and proc_macro_crate_impl? Why not just have one crate? Does it offer any benefits to to overall compilation times? An example of this can be seen in the thiserror crate where there's a thiserror and thiserror_impl crate.

You might want to use thiserror to generate implementation for Error and Display.

thiserror for my error types.

thiserror - https://crates.io/crates/thiserror

I dont think you realize how ridiculous this comment is. Youre comparing 10 lines of Go, with 200 of Rust:

https://github.com/dtolnay/thiserror/blob/master/src/lib.rs

There are crates out there that help you reduce this boiler plate. thiserror is good for creating custom errors and color-eyre or anyhow are good for dynamic errors.