如何将Swift枚举的function类型case作为参数传递？

我一直在用Codable枚举处理类的JSON编码，但遇到了一个瓶颈。先看我的枚举定义：

enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)    
}

我想写一个函数，接收枚举的某个case（比如MyEnum.case1）作为参数，在函数内部处理数据后返回对应case的实例。但直接用MyEnum作为参数类型行不通——因为MyEnum.case1本质是个函数类型（(Data) -> MyEnum），和MyEnum类型不匹配。我最初尝试的写法会报错：

// 调用尝试
myFunc(myEnumType: MyEnum.case1)

func myFunc(
    myEnumType: MyEnum // 类型不匹配，编译报错
) -> MyEnum {
            
    switch myEnumType {
    
    case .case1:
        // 处理逻辑...
        return myEnumType(data: ...) // 这里也会报错
    case .case2:
        // ...
        return myEnumType(str: ...)
    case .case3:
        // ...
        return myEnumType(url: ...)
        
    }
}

无奈之下，我只能用一个很繁琐的 workaround：额外声明一个枚举来标记case类型：

enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)    
}

// 额外声明的枚举，仅用于标记case类型
enum MyEnumType {
    case case1
    case case2
    case case3
}

// 调整后的函数
func myFunc(
    myEnumType: MyEnumType
) -> MyEnum {
    // 根据MyEnumType的case创建对应MyEnum实例
}

但这个方案太冗余了，我想找到更简洁的方式：如何直接将枚举的case作为参数传递给函数，无需额外声明枚举或用假数据初始化case？

我尝试过但不满意的方案 #

• 过于泛化的类型别名：

typealias MyEnumType<Arg1> = (Arg1) -> MyEnum

这个类型允许任何返回MyEnum的函数传入，无法保证一定是MyEnum自身的case构造器，类型不安全。

• 用假数据初始化case：

myFunc(myEnumType: MyEnum.case1(data: dummyData))

我不想用假数据占位，函数应该自己生成实际数据并初始化实例。

• 传递枚举类型本身：

myFunc(myEnumType: MyEnum)

这完全没有意义，我需要明确知道具体的case来执行对应的初始化逻辑。

我的理想方案是类似这样的写法，能确保传入的是MyEnum的case构造器，同时不需要额外声明或初始化：

func myFunc<T>(myEnumType: MyEnum.T) -> MyEnum {
    // 函数逻辑
}

可行的解决方案 #

方案一：函数重载匹配构造器类型

通过为每个case的构造器定义专属类型别名，再重载myFunc来匹配这些类型，既保证类型安全，又能直接传入枚举case：

enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)
    
    // 为每个case的构造器定义类型别名
    typealias Case1Constructor = (Data) -> MyEnum
    typealias Case2Constructor = (String) -> MyEnum
    typealias Case3Constructor = (URL) -> MyEnum
}

// 重载函数，分别处理每个case的构造器
func myFunc(constructor: MyEnum.Case1Constructor) -> MyEnum {
    // 这里替换成你的data处理逻辑
    let processedData = Data()
    return constructor(processedData)
}

func myFunc(constructor: MyEnum.Case2Constructor) -> MyEnum {
    let processedString = "processed_content"
    return constructor(processedString)
}

func myFunc(constructor: MyEnum.Case3Constructor) -> MyEnum {
    let processedURL = URL(string: "https://example.com")!
    return constructor(processedURL)
}

// 调用方式非常直观
let result1 = myFunc(constructor: MyEnum.case1)
let result2 = myFunc(constructor: MyEnum.case2)
let result3 = myFunc(constructor: MyEnum.case3)

这个方案的优势是类型严格，调用简洁，不需要额外封装。

方案二：用枚举封装构造器（统一处理所有case）

如果需要在一个函数中处理所有case，可以创建专门的枚举来封装每个case的构造器，这样既保证类型安全，又能通过switch统一处理：

enum MyEnum: Codable {
    case case1(data: Data)
    case case2(str: String)
    case case3(url: URL)
}

// 封装构造器的枚举，每个case关联对应的构造器函数
enum MyEnumConstructor {
    case case1((Data) -> MyEnum)
    case case2((String) -> MyEnum)
    case case3((URL) -> MyEnum)
    
    // 便捷初始化，自动推断构造器类型
    init(_ constructor: @escaping (Data) -> MyEnum) {
        self = .case1(constructor)
    }
    
    init(_ constructor: @escaping (String) -> MyEnum) {
        self = .case2(constructor)
    }
    
    init(_ constructor: @escaping (URL) -> MyEnum) {
        self = .case3(constructor)
    }
}

func myFunc(constructor: MyEnumConstructor) -> MyEnum {
    switch constructor {
    case .case1(let build):
        let data = Data() // 处理逻辑
        return build(data)
    case .case2(let build):
        let str = "processed_content" // 处理逻辑
        return build(str)
    case .case3(let build):
        let url = URL(string: "https://example.com")! // 处理逻辑
        return build(url)
    }
}

// 调用方式
let result1 = myFunc(constructor: MyEnumConstructor(MyEnum.case1))
// 利用Swift自动类型推断，也可以简化写法
let result2 = myFunc(constructor: .case2(MyEnum.case2))

这个方案适合需要统一处理所有case的场景，避免了多个重载函数的冗余。

内容的提问来源于stack exchange，提问作者benhatsor