                      Represents a `Data` object containing
                      a byte array.
 
-    - receiver:      Contains a `Stream` that can be drained
+    - receiver:      Contains a `ReceivingStream` that can be drained
                      in chunks to access the body's data.
 
-    - sender:        Contains a closure that accepts a `Stream`
+    - sender:        Contains a closure that accepts a `SendingStream`
                      object to which the body's data should be sent.
  
-    - asyncReceiver: Contains a `AsyncStream` that can be drained
+    - asyncReceiver: Contains a `AsyncReceivingStream` that can be drained
                      in chunks to access the body's data.
  
-    - asyncSender:   Contains a closure that accepts a `AsyncStream`
+    - asyncSender:   Contains a closure that accepts a `AsyncSendingStream`
                      object to which the body's data should be sent.
  
 */
 public enum Body {
     case buffer(Data)
-    case receiver(Stream)
-    case sender((Stream) throws -> Void)
-    case asyncReceiver(AsyncStream)
-    case asyncSender((AsyncStream, ((Void) throws -> Void) -> Void) -> Void)
+    case receiver(ReceivingStream)
+    case sender((SendingStream) throws -> Void)
+    case asyncReceiver(AsyncReceivingStream)
+    case asyncSender((AsyncSendingStream, ((Void) throws -> Void) -> Void) -> Void)
 }
 
 public enum BodyError: ErrorProtocol {

    
    /**
     Converts the body's contents into a closure
     that accepts a `AsyncStream`.
     */
    public mutating func becomeAsyncSender(timingOut deadline: Double = .never, completion: ((Void) throws -> (Body, ((AsyncStream, ((Void) throws -> Void) -> Void) -> Void))) -> Void) {
        
        switch self {
        case .buffer(let data):
            let closure: ((AsyncStream, ((Void) throws -> Void) -> Void) -> Void) = { sender, result in
                sender.send(data, timingOut: deadline) { closure in
                    result {
                        try closure()

    
    
    /**
     Converts the body's contents into a `AsyncReceivingStream`
     that can be received in chunks.
     */
    public mutating func becomeAsyncReceiver(completion: ((Void) throws -> (Body, AsyncReceivingStream)) -> Void) {
        switch self {
        case .asyncReceiver(let stream):
            completion {
