     /// Bind to a `SocketAddress`.
     /// - parameters:
     ///       - to: the `SocketAddress` to which we should bind the `Channel`.
-    /// - returns: the future which will be notified once the operation completes.
-    func bind(to: SocketAddress) -> EventLoopFuture<Void>
-
-    /// Bind to a `SocketAddress`.
-    /// - parameters:
-    ///       - to: the `SocketAddress` to which we should bind the `Channel`.
     ///       - promise: the `EventLoopPromise` that will be notified once the operation completes,
     ///                  or `nil` if not interested in the outcome of the operation.
     func bind(to: SocketAddress, promise: EventLoopPromise<Void>?)
-
-    /// Connect to a `SocketAddress`.
-    /// - parameters:
-    ///       - to: the `SocketAddress` to which we should connect the `Channel`.
-    /// - returns: the future which will be notified once the operation completes.
-    func connect(to: SocketAddress) -> EventLoopFuture<Void>
 
     /// Connect to a `SocketAddress`.
     /// - parameters:

    var eventLoop: EventLoop { get }
}

/// Default implementations for `ChannelOutboundInvoker` methods. Each method that returns a `EventLoopFuture` will just do the following:
///     - create a new `EventLoopPromise<Void>`
///     - call the corresponding method that takes a `EventLoopPromise<Void>`
///     - return `EventLoopPromise.futureResult`
extension ChannelOutboundInvoker {
    public func register() -> EventLoopFuture<Void> {
        let promise = makePromise()
        register(promise: promise)
        return promise.futureResult
    }

    public func bind(to address: SocketAddress) -> EventLoopFuture<Void> {
        let promise = makePromise()
        bind(to: address, promise: promise)
        return promise.futureResult
    }

    public func connect(to address: SocketAddress) -> EventLoopFuture<Void> {
        let promise = makePromise()
        connect(to: address, promise: promise)
        return promise.futureResult
    }

    public func write(_ data: NIOAny) -> EventLoopFuture<Void> {
        let promise = makePromise()
        write(data, promise: promise)
        return promise.futureResult
    }

    public func writeAndFlush(_ data: NIOAny) -> EventLoopFuture<Void> {
        let promise = makePromise()
        writeAndFlush(data, promise: promise)
        return promise.futureResult
    }

    public func close(mode: CloseMode = .all) -> EventLoopFuture<Void> {
        let promise = makePromise()
        close(mode: mode, promise: promise)
        return promise.futureResult
    }

    public func triggerUserOutboundEvent(_ event: Any) -> EventLoopFuture<Void> {
        let promise = makePromise()
        triggerUserOutboundEvent(event, promise: promise)
        return promise.futureResult
    }

    ///
    /// - parameters:
    ///       - data: the data to write
    ///       - promise: the `EventLoopPromise` that will be notified once the operation completes,
    ///                  or `nil` if not interested in the outcome of the operation.
    func write(_ data: NIOAny, promise: EventLoopPromise<Void>?)
