 #endif
     }
 
-     func whenReady(strategy: SelectorStrategy, _ fn: (SelectorEvent<R>) throws -> Void) throws -> Void {
+    /// Apply the given `SelectorStrategy` and execute `fn` once it's complete (which may produce `SelectorEvent`s to handle).
+    ///
+    /// - parameters:
+    ///     - strategy: The `SelectorStrategy` to apply
+    ///     - fn: The function to execute for each `SelectorEvent` that was produced.
+    func whenReady(strategy: SelectorStrategy, _ fn: (SelectorEvent<R>) throws -> Void) throws -> Void {
         guard self.lifecycleState == .open else {
             throw IOError(errnoCode: EBADF, reason: "can't call whenReady for selector as it's \(self.lifecycleState).")
         }

#endif
    }

    public func close() throws {
        guard self.lifecycleState == .open else {
            throw IOError(errnoCode: EBADF, reason: "can't close selector as it's \(self.lifecycleState).")

    }
}

/// The strategy used for the `Selector`.
enum SelectorStrategy {
    /// Block until there is some IO ready to be processed or the `Selector` is explictly woken up.
    case block

    /// Block until there is some IO ready to be processed, the `Selector` is explictly woken up or the given `TimeAmount` elapsed.
    case blockUntilTimeout(TimeAmount)
    
    /// Try to select all ready IO at this point in time without blocking at all.
    case now
}

/// The IO for which we want to be notified.
public enum IOEvent {
    /// Something is ready to be read.
    case read
    
    /// Its possible to write some data again.
    case write
    
    /// Combination of `read` and `write`.
    case all
    
    /// Not interested in any event.
    case none
}
