多次调用swift闭包是否正确

我正在设计一个swift api,在这里我定义了一个协议 EventTransmitter 用一种方法传送一批 Events 是的。处理一批 事件 可以以成功和失败事件的列表结尾。

因此,该协议的任何实现都应该用失败的事件和/或成功的事件来调用完成。

public enum EventResult {

    /// When the event was transmitted correctly.
    case success([Event])

    /// When the event failed and should be discarded
    case failure([Event])
}

public protocol EventTransmitter {

    func transmit(events: [Event], completion: @escaping (EventResult) -> Void)
}

使用上述协议,实现协议的人必须调用两次完成:

public class HTTPTransmitter: EventTransmitter {

    public func transmit(events: [Event], completion: @escaping (EventResult) -> Void) {

        let failedEvents =  ...
        let successEvents = ...

        completion(.failure(failedEvents))

        completion(.success(successEvents))
    }
}

它的用法是

transmitter.transmit(events: events, completion: { result in
    switch result {
    case .success(let events):
        // handle success events
    case .failure(let events):
        // handle failed events
    }
})

要求完成一次关闭好几次是正确的吗?

或者,对于每种情况,使用不同的闭包是否更合适:

public protocol EventTransmitter {

    typealias EventCallback = (([Event]) -> Void)

    func transmit(events: [Event], onSuccess: @escaping EventCallback, onFailure: @escaping EventCallback)
}