Generic type not preserved when called within another generic function

[Updated with a less contrived example]

I'm trying to extend a generic function to provide different behavior for a specific type. This works as expected when I call the function directly. But If I call it from within another generic function, the original generic type is not preserved and I get the default behavior. I'm a bit new to Swift, so I may be missing something obvious here.

My code looks something like this:

protocol Task {
    associatedtype Result
}

struct SpecificTask: Task {
    typealias Result = String
    
    // other taks related properties
}

enum TaskRunner<T: Task> {
    static func run(task: T) throws -> T.Result {
        // Task not supported
        throw SomeError.error
    }
}

extension TaskRunner where T == SpecificTask {
    static func run(task: T) throws -> T.Result {    
        // execute a SpecificTask
        return "Some Result"
    }
}

func run<T: Task>(task: T) throws -> T.Result {
    // Additional logic related to running the task
    return try TaskRunner.run(task: task)
}

print(try TaskRunner.run(task: SpecificTask())) // Prints "Some Result"
print(try run(task: SpecificTask()))            // Throws SomeError

I need the top-level run function to call the SpecificTask version of the lower-level run() function, but the generic version of the function is called instead

from Recent Questions - Stack Overflow https://ift.tt/3D89TTR
https://ift.tt/eA8V8J