如何在 Swift 中实现通用约束？

Question

Imagine we have a generic enum like this:

enum GenericEnum<T> {
    case typed(T)
    case untyped(Error)
}

For the sake of easier access for some UI work, we have to implement an extension for this:

extension GenericEnum {
    
    var validValue: T? {
        if case .typed(let value) = self {
            return value
        } else {
            return nil
        }
    }
}

validValue returns the actual value or nil . And we can use it like:

let genericEnums = [GenericEnum.typed(1), GenericEnum.typed(2), GenericEnum.typed(3)]
let result = genericEnums.compactMap { $0.validValue }

So far, so good.

The issue

Now for more easy to call code, I want to move the usage method into an extension on the Array like:

extension Array where Element == GenericEnum<Int> { // `Int` should be generic here
    var customCompacted: [Int] { // `Int` should be generic here
        compactMap { $0.validValue }
    }
}

But I need Int to be generic , but all attempts raise an error like:

Reference to generic type 'GenericEnum' requires arguments in <...>

And more different errors about generics and constraints. How can I make this generic?

---

_{The example provided in this question is just for others to quickly reproduce the situation and may not use in the real world project. The answer is going to show how we can use some of the powered features of Swift}

Answer 1

I think that you cannot constrain an extension like that. But you can define a constrained method instead:

extension Array {
    func customCompacted<T>() -> [T] where Element == GenericEnum<T> {
        return compactMap { $0.validValue }
    }
}

Usage examples:

let genericInts = [GenericEnum.typed(1), GenericEnum.typed(2), GenericEnum.typed(3)]
print(genericInts.customCompacted()) // [1, 2, 3]

let genericDoubles = [GenericEnum.typed(1.0), GenericEnum.typed(2.0), GenericEnum.typed(3.0)]
print(genericDoubles.customCompacted()) // [1.0, 2.0, 3.0]

---

An alternative is to define a protocol to which GenericEnum conforms:

enum GenericEnum<T> {
    case typed(T)
    case untyped(Error)
}

protocol GenericEnumProtocol {
    associatedtype T
    var validValue: T? { get }
}

extension GenericEnum: GenericEnumProtocol {
    var validValue: T? {
        if case .typed(let value) = self {
            return value
        } else {
            return nil
        }
    }
}

extension Array where Element : GenericEnumProtocol {
    var customCompacted: [Element.T] { // `Int` should be generic here
        compactMap { $0.validValue }
    }
}