Swift中条件一致性的解决方法（是：将协议添加到受约束的泛型类型中）

Question

The code snippet below demonstrates the problem I am trying to solve.

import Foundation

protocol Printable {
    func className() -> String
}

class SomeType: Printable {
    func className() -> String {
        return "SomeType"
    }
}

class List<T> {
}

extension List where T: SomeType {
    func className() -> String {
        return "List<SomeType>"
    }
}

func test(type: Any, message: String) {
    guard type is Printable else {
        print("\(message): ERROR")
        return
    }
    print("\(message): SUCCESS")
}

let s: Any = SomeType()
test(type: s, message: "#1")

let slist1: Any = List<Any>()
test(type: slist1, message: "#2")

let slist2: Any = List<SomeType>()
test(type: slist2, message: "#3")

How can I get this:

> #1: SUCCESS  <--- as expected
> #2: ERROR    <--- it's okay
> #3: SUCCESS  <--- I am getting ERROR instead

It seems that adding a protocol to this line would do the trick:

extension List: Printable where T: SomeType { // COMPILE ERROR

But unfortunately, this is not allowed.

Another way to do it could be to use:

extension List where T: Printable { // COMPILES OK in Swift 2.3 but doesn't work. COMPILE ERROR in Swift 3.0

But again, no luck passing the test.

What else can I do to add a protocol to a constrained generic type?

Answer 1

Okay so in your guard you're asking "if this is Printable then print success else print Error" and with your first example you have s which is SomeType which is printable. That's fine.

After that you have slist1 which is type List<Any> which is definitely not of type printable and you get "Error". That's fine

Next you have List<SomeType> . Now you have a class extension that defines T to be SomeType, correct? But you're only defining T to be SomeType and not the actual List so when you pass the entire List into the test function you're not going to get your test to pass because List<AnyTypeHere> is not Printable because the list itself doesn't implement Printable.

Now the question is, do you want the entire list to be printable? If so, then just make it conform to the SomeType or Printable protocol. That's the only way you'll get that to pass other than you passing individual List<SomeType> elements into the function. Your function logic is correct but it's just a misuse of the concept.

So if you want the List<SomeType> to make that pass then you could do something like

class List<T> : Printable where T:SomeType {
  //Add code here that conforms to protocol
}

Doing that will make your second test fail because Any doesn't inherit from SomeType but it'll make your third test pass because now List<T> is Printable and T is also of type SomeType. I mean, that's just a real quick way to get what it looked like you wanted to begin with. You're not going to have the second and third tests pass at the same time unless you add something extra because the second test is List being of type Any while the third is List being of type Printable. So either one of them will throw an error (because List isn't of type Printable) or all tests show success (because List is of type Printable)

Answer 2

An updated answer now that we have Swift 4.2, conditional conformance is now added as a feature.

From their spec on Github , this sort of code is now valid

   extension List : Printable where T: SomeType {
       func className() -> String {
           return "List<SomeType>"
       }
   }