Once failed, a stream can not be restarted such that all future reads will resolve into a failure. There is no need to discard an already failed stream.

Resource Safety

One of the important implications of readers, and streams in general, is that they are prone to resource leaks unless fully consumed or discarded (failed). Specifically, readers backed by network connections MUST be discarded unless already consumed (EOF observed) to prevent connection leaks.

The read-loop above, for example, exhausts the stream (observes EOF) hence does not have to discard it (stream).

Back Pressure

The pattern above leverages com.twitter.util.Future recursion to exert back-pressure via allowing only one outstanding read. It's usually a good idea to structure consumers this way (i.e., the next read isn't issued until the previous read finishes). This would always ensure a finer grained back-pressure in network systems allowing the consumers to artificially slow down the producers and not rely solely on transport and IO buffering.

Whether or not multiple outstanding reads are allowed on a Reader type is an undefined behaviour but could be changed in a refinement.

Cancellations

If a consumer is no longer interested in the stream, it can discard it. Note a discarded reader (or stream) can not be restarted.

def consumeN[A](r: Reader[A], n: Int)(process: A => Future[Unit]): Future[Unit] =
  if (n == 0) Future(r.discard())
  else r.read().flatMap {
    case Some(a) => process(a).before(consumeN(r, n - 1)(process))
    case None => Future.Done // reached the end of the stream; no need to discard
  }