Passing protocol conforming type via generics not working in Swift

Generic Type Passing in Swift

In Swift, passing protocol conforming types via generics can be a tricky matter. It's common to encounter errors like 'P.Type' is not convertible to 'P' when attempting to pass a protocol type as a generic parameter. To avoid these errors and achieve the desired functionality, there are a few approaches you can take.

Passing Type as Variable

One solution is to pass the type as a variable to the generic method. This can be achieved by defining a generic method that accepts a type as an argument. For instance:

 
struct Computer {
    static func compute(with anyP: P.Type) -> P {
        anyP.instance()
    }
}

In this case, you can call compute like this:

for value in someArray {
    let instance = Computer.compute(with: value)
    instance.doSomething()
}

This approach allows you to pass any type conforming to the P protocol to the compute method, and it will return an instance of that type.

Constraining the Generic Method

Another approach is to constrain the generic method to accept only types conforming to the P protocol. This can be done by adding a generic constraint to the method:

struct Computer {
    static func compute(with anyP: T.Type) -> T {
        anyP.instance()
    }
}

With this method definition, you'll need to explicitly specify the generic type when calling compute:

for value in someArray {
    let instance = Computer.compute(with: value)
    instance.doSomething()
}

This approach ensures that only types conforming to the P protocol can be passed to the compute method.

Extending the Protocol

If you don't need the generic Computer struct, you can directly extend the P protocol to add a compute method:

extension P {
    static func compute() -> Self {
        instance()
    }
}

let someArray: [P.Type] = [
    A.self,
    B.self
]

for value in someArray {
    value.compute()
}

This approach allows you to call the compute method directly on the protocol type.

Conclusion

When working with protocol conforming types and generics in Swift, it's important to understand the constraints and limitations of the language. By using the appropriate approach, you can effectively pass protocol types as generic parameters and achieve the desired functionality in your code.