Long running processes handling lots of different requests, not so much, and that's made up an increasing amount of what people want to do.
But for "open a file, chew through it, errors when consuming it might as well take down the process" nothing could be easier.
I've used conduits before, and understand that pipes fit the same design space.
But most of the time I just use read and write operations exposed by Bytestring, etc.
My point is that since I like IO today, and I didn't think that laziness had been removed, then I probably would have liked IO back in the day.
The operations provided by `Data.ByteString` do not work like this; the ByteString you get back represents a buffer, and it has already been processed by the time the RHS of >>= starts executing.
The operations provided by `Data.ByteString.Lazy`, on the other hand, do work like that; the ByteString you get back is a linked sequence of buffers, and some of those links might be thunks to go get the next bits of the ByteString for you.
This is why a Data.ByteString.ByteString and a Data.ByteString.Lazy.ByteString are different types, and you can't just pass one where the other is expected (unless you've abstracted over it) - they're actually shaped differently.
From Oleg Kiselyov's 2012 paper Iteratees [1]:
This is a very famous Haskell programer's opinion on the default IO in Haskell, and he quotes that one of the main creators of the language himself anticipated such problems [2]. Why downvote a comment in 2021 challenging the claim that "Haskell's had a great story around IO for 29 years"?[1]: http://okmij.org/ftp/Haskell/Iteratee/describe.pdf
[2]: https://www.microsoft.com/en-us/research/wp-content/uploads/...