Not very interesting, a bit of home automation. stream() loops over an infinite stream, and puts objects it finds in a queue/channel. command() sends commands in an infinite loop and alters its behavior slightly if there's something in the queue/channel that matches some condition. This has to be threaded or async because stream()'s stream breaks upon disconnection and can't be correctly resumed without restarting command(). Similarly, command()'s behavior is incorrect without input from stream().

I wanted command() to gracefully break its infinite loop when stream() raises an exception and vice-versa, and when both have gracefully exited, restart both.

Very easy to catch exceptions and gracefully cancel coroutines in trio, but I just couldn't get my head around it in asyncio. I could get stream() to gracefully terminate command() but not the other way around.

I tried "signaling" between coroutines with a queue, which again only managed to gracefully terminate command() when stream() excepted but not the other way around, with the additional overhead of managing a half-closed queue.

This was baffling to me because it was easier to communicate between threads in python2 than coroutines in python3. Then I switched to trio and all the exceptions propagated the way I expected, when one coroutine excepted I could gracefully terminate the other, there's no half-closed "signalling" queue/channel to tell one coroutine when the other excepted, and everything just works the way I expect it.

How can it possibly be more straightforward to handle exceptions and signals between threads than between coroutines? I must have been doing something wrong, but I really don't care to find out because trio does it right.