 
         repeat {
             do {
-                try _attemptClosure(call:  {
+                try _attemptClosure(funcCall: {
                                         return nn_close(fileDescriptor)
                                     },
-                                    error: { errno in
+                                    failure:  { errno in
                                         return .Close(code: errno)
                                     })
             } catch NanoMessageError.Interrupted {

    @discardableResult
    public func removeEndPoint(_ endPoint: EndPoint) throws -> Bool {
        if (endPoints.contains(endPoint)) {
            try _attemptClosure(call:  {
                                    return nn_shutdown(fileDescriptor, CInt(endPoint.id))
                                },
                                error: { errno in
                                    return .RemoveEndPoint(code: errno, url: endPoint.url, endPointId: endPoint.id)
                                })


    ///   - nanoSocket: The socket to bind too.
    ///   - queue:      The dispatch queue to use
    ///   - group:      The dispatch group to use.
    ///   - failure:    The closure to use if the 'bindToSocket()' fails.
    ///
    /// - Returns:          The despatched work item.
    public func bindToSocket(_ nanoSocket: NanoSocket,
                             queue:        DispatchQueue,
                             group:        DispatchGroup,
                             failure:      @escaping (Error) -> Void) -> DispatchWorkItem {
        return _dispatchWorkItem(queue:    queue,
                                 group:    group,
                                 funcCall: {
                                     try self.bindToSocket(nanoSocket)
                                 },
                                 failure:  failure)
    }

    /// Starts a 'loopback' on the socket, it loops and sends any messages received from the socket back to itself.
