- `reader` is too hard to use, even a single blocking I/O operation on anything other than the `Shutdown` implementor breaks it
  - given that the point of `reader` is to *allow* (cancelable) I/O, this occurs too often to be practical
  -> remove it?
- move `background`/`Worker` etc. into a `thread` module
- "isochronous" stream processing that replicates the input data pacing at the output while running
  the computation pipelined on a thread pool

reactive value sketch

impl Value<T> {
    pub fn new() -> Self { ... }

    pub fn set(&self, value: T) { ... }

    pub fn reader(&self) -> Reader<T> { ... }
    pub fn reader_count(&self) -> usize { ... }
}

impl Reader<T> {
    pub fn get(&self) -> Option<T> { ... }
    pub fn next(&self) -> Option<T> { ... }

    pub async fn wait(&self) -> T { ... }
    pub fn block(&self) -> T { ... }
}


isochronous processor might be better as a `Stream` extension (`stream.pace()`?)
a better name relating to "wall clock time" might also be better