Swift Generic Issue extending API

In Swift I need to be able to generically work with the various Token<T> given to me by an API.

Note that I'm Using Swift 5.8.

The API defines the following (only showing relevant parts):

public struct Token<T> : Codable, Equatable, Hashable { }

public struct Application : Equatable, Hashable {
    public let token: ApplicationToken?
}

public struct ActivityCategory : Equatable, Hashable {
    public let token: ActivityCategoryToken?
}

public struct WebDomain : Equatable, Hashable {
    public let token: WebDomainToken?
}

public typealias ApplicationToken = Token<Application>
public typealias ActivityCategoryToken = Token<ActivityCategory>
public typealias WebDomainToken = Token<WebDomain>


// Data the API gives me:
struct ActivitySelection {
    public var applicationTokens: Set<ApplicationToken>
    public var categoryTokens: Set<ActivityCategoryToken>
    public var webDomainTokens: Set<WebDomainToken>
}

I tried doing this:

// My custom ActivityType:
enum ActivityType {
    case Applications
    case Categories
    case WebDomains
}

// My API Extension
extension ActivitySelection {
    func tokensFor<T>(activity:ActivityType) -> [Token<T>] {
        let array: [Token<T>]
        switch activity {
            case .Applications:
                array = Array(self.applicationTokens) as! [Token<T>]
            case .Categories:
                array = Array(self.categoryTokens) as! [Token<T>]
            case .WebDomains:
                array = Array(self.webDomainTokens) as! [Token<T>]
        }
        // sort before returning here removed for simplicity
        return array
    }
}

let selection = ActivitySelection() // returns with data

Then when I try to use my extension:

let tokens = selection.tokensFor(activity: .Applications)

I get this error:

• XCode Error: Generic parameter 'T' could not be inferred

If I try this:

    func tokensFor<T>(activity:Activities) -> [Token<T>] {
        let array: [Token<T>]
        switch activity {
            case .Applications:
                array = Array(self.applicationTokens)
            case .Categories:
                array = Array(self.categoryTokens)
            case .WebDomains:
                array = Array(self.webDomainTokens)
        }
        // sort before returning here
        return array
    }

I get:

• Cannot assign value of type '[ApplicationToken]' (aka 'Array<Token<Application>>') to type '[Token<T>]'
• Cannot assign value of type '[ActivityCategoryToken]' (aka 'Array<Token<ActivityCategory>>') to type '[Token<T>]'
• Cannot assign value of type '[WebDomainToken]' (aka 'Array<Token<WebDomain>>') to type '[Token<T>]'

I've also tried it this way:

    func tokensFor(activity:Activities) -> [Token<Any>] {
        let array: [Token<Any>]
        switch activity {
            case .Applications:
                array = Array(self.applicationTokens)
            case .Categories:
                array = Array(self.categoryTokens)
            case .WebDomains:
                array = Array(self.webDomainTokens)
        }
        // sort before returning here
        return array
    }

But I get errors:

• Cannot assign value of type '[ApplicationToken]' (aka 'Array<Token<Application>>') to type '[Token<Any>]'
• Cannot assign value of type '[ActivityCategoryToken]' (aka 'Array<Token<ActivityCategory>>') to type '[Token<Any>]'
• Cannot assign value of type '[WebDomainToken]' (aka 'Array<Token<WebDomain>>') to type '[Token<Any>]'

How can I make this work? I thought generics was the solution to this very problem.

Since Token<T> is already a generic type, how do I use that to work with the 3 different token types generically?

The reason why using an enum doesn't work is that enum values could only be known at runtime:

let tokens = tokensFor(activity: randomlyGenerateAnActivity())

If randomlyGenerateAnActivity randomly chooses one of the three cases, what would be the compile-time type of tokens? The compiler cannot know.

One solution would be to make such a type, a non-generic type that wraps a Token<T>, replacing everything in Token<T> that involves T with something similar, except T is replaced with Any. Since you don't want to show what members Token<T> has, I can't give any code examples for this.

Another solution would be to make tokensFor take a metatype as a parameter.

// make Application, ActivityCategory, and WebDomain conform to this
public protocol TokenType {
    var token: Token<Self>? { get }
}

extension ActivitySelection {
    func tokensFor<T: TokenType>(_ tokenType: T.Type) -> [Token<T>] {
        let array: [Token<T>]
        if tokenType == Application.self {
            array = Array(self.applicationTokens) as! [Token<T>]
        } else if tokenType == ActivityCategory.self {
            array = Array(self.categoryTokens) as! [Token<T>]
        } else if tokenType == WebDomain.self {
            array = Array(self.webDomainTokens) as! [Token<T>]
        } else {
            fatalError("Invalid Token Type")
        }
        // sort before returning here removed for simplicity
        return array
    }
}

Now the type that tokensFor will return is always known at compile time.

Note that instead of using if...else if to check the type, you could also add a static property in the protocol that returns the corresponding key path:

// implement this property in each of the three types
static var activitySelectionKeyPath: KeyPath<ActivitySelection, Set<Token<Self>>> { get }

Then you can just get the array in tokensFor from self[keyPath: T.activitySelectionKeyPath].

<hr>

Since you are displaying the tokens in a SwiftUI view, you should make a generic View, and pass that generic parameter into tokensFor:

public struct SomeGenericView<T: TokenType>: View {
    let activitySelection = ActivitySelection()
    
    public var body: some View {
        ForEach(activitySelection.tokensFor(T.self), id: \.something) { token in
            Text("\(token)")
        }
    }
}

Then you can make three of this SomeGenericView:

// in a parent view...
public var body: some View {
    SomeGenericView<Application>()
    SomeGenericView<ActivityCategory>()
    SomeGenericView<WebDomain>()
}

This signature does not mean what you think it means:

func tokensFor<T>(activity:ActivityType) -> [Token<T>] {

This says that the caller can pick any type that can possibly exist (a String, Int, random struct they just defined, UIViewController, anything), and this function promises to return a Token wrapping that type. And this will all be decided statically, at compile-time. That's not how Token works, and it's not what you mean.

Instead, the goal is to return a Token type that is only known at runtime. That is the standard use for a protocol.

protocol TokenType {
    // Here you would generally put any methods the caller needs to be 
    // able to call on the returned token.
}

extension Token: TokenType {
    // This can probably be empty, but if Token needs some new methods to
    // conform to TokenType, add them here.
}

extension ActivitySelection {
    // Now return an Array of "any kind of Token, known at runtime"
    func tokensFor(activity: ActivityType) -> [any TokenType] {
        let array: [any TokenType]
        switch activity {
            case .Applications:
                array = Array(self.applicationTokens)
            case .Categories:
                array = Array(self.categoryTokens)
            case .WebDomains:
                array = Array(self.webDomainTokens)
        }
        // sort before returning here removed for simplicity
        return array
    }
}