你如何定义一个可以保存一组特定闭包签名的变量？

Question

考虑下面的代码。它允许您通过传入可以处理有效负载的闭包来实例化处理器。闭包可以是六种签名类型之一。以下是我的实现方式：

我想知道是否有更简单/更好的方法来写这个。我可能正在考虑使用具有关联值的枚举，但这意味着我必须将闭包包装在枚举中，然后将枚举传递给初始化程序。我希望尽可能避免这种情况。

struct Payload {
    let stringVal : String
    let intVal    : Int
}

class Processor{

    init(action:Any){

        switch action {
            case let action as ()       -> Void,
                 let action as ()       -> Error?,
                 let action as (String) -> Void,
                 let action as (String) -> Error?,
                 let action as (Int)    -> Void,
            case let action as (Int)    -> Error?,
            default: fatalError("Action does not have a supported signature")
        }

        self.action = action
    }

    let action:Any

    func performAction(payload:Payload) -> Error? {

        switch action {

            case let action as () -> Void:
                action()

            case let action as () -> Error?:
                return action()

            case let action as (String) -> Void:
                action(payload.stringVal)

            case let action as (String) -> Error?:
                return action(payload.stringVal)

            case let action as (Int) -> Void:
                action(payload.intVal)

            case let action as (Int) -> Error?:
                return action(payload.intVal)

            default: fatalError("Action does not have a supported signature")
        }

        return nil
    }
}

另外，在我执行模式匹配以确定我是否有有效匹配的初始化程序中，我收到一个编译器警告，说我已经设置，但从未使用过action。但是，如果我将其替换为 _，则会收到一条警告，指出我没有绑定到模式中的任何内容。如何在对我不关心值是什么的模式执行测试的同时抑制警告？

Answer 1

避免使用Any 类型的参数。使用具有关联类型的枚举：

enum Action {
    case a1(() -> Void)
    case a2(() -> Error?)
    case a3((String) -> Void)
    case a4((String) -> Error?)
    case a5((Int) -> Void)
    case a6((Int) -> Error?)
}

struct Payload {
    let stringVal : String
    let intVal    : Int
}

class Processor{
    let action: Action

    init(action: Action) {
        self.action = action
    }

    func performAction(payload: Payload) -> Error? {
        var error: Error? = nil
        switch action {
        case let .a1(closure):
            closure()
        case let .a2(closure):
            error = closure()
        case let .a3(closure):
            closure(payload.stringVal)
        case let .a4(closure):
            error = closure(payload.stringVal)
        case let .a5(closure):
            closure(payload.intVal)
        case let .a6(closure):
            error = closure(payload.intVal)
        }

        return error
    }
}

这确保您只能将有效操作传递给您的 Payload 类。

Action case 值需要一个更好的命名约定，但这会让你开始。

这是一个用法示例：

let payload = Payload(stringVal: "Hello", intVal: 42)
let myAction = {
    print("Working")
}
let action = Action.a1(myAction)
let processor = Processor(action: action)
let error = processor.performAction(payload: payload)

另一种方法是将Action 设置为Processor 内部，并为Processor 提供6 个初始化器。

struct Payload {
    let stringVal : String
    let intVal    : Int
}

class Processor{
    enum Action {
        case a1(() -> Void)
        case a2(() -> Error?)
        case a3((String) -> Void)
        case a4((String) -> Error?)
        case a5((Int) -> Void)
        case a6((Int) -> Error?)
    }

    private let action: Action

    init(_ closure: @escaping () -> Void) {
        self.action = .a1(closure)
    }

    init(_ closure: @escaping () -> Error?) {
        self.action = .a2(closure)
    }

    init(_ closure: @escaping (String) -> Void) {
        self.action = .a3(closure)
    }

    init(_ closure: @escaping (String) -> Error?) {
        self.action = .a4(closure)
    }

    init(_ closure: @escaping (Int) -> Void) {
        self.action = .a5(closure)
    }

    init(_ closure: @escaping (Int) -> Error?) {
        self.action = .a6(closure)
    }

    func performAction(payload: Payload) -> Error? {
        var error: Error? = nil
        switch action {
        case let .a1(closure):
            closure()
        case let .a2(closure):
            error = closure()
        case let .a3(closure):
            closure(payload.stringVal)
        case let .a4(closure):
            error = closure(payload.stringVal)
        case let .a5(closure):
            closure(payload.intVal)
        case let .a6(closure):
            error = closure(payload.intVal)
        }

        return error
    }
}

let payload = Payload(stringVal: "Hello", intVal: 42)
let myAction = {
    print("Working")
}
let processor = Processor(myAction)
let error = processor.performAction(payload: payload)