Static member 'currency' cannot be used on protocol metatype 'SomeProtocol.Type'

I will give you some context first. I'm trying to make a function that takes as a parameter any type that conforms to a protocol (SomeProtocol). So, I created a struct with static method called currency and this struct conforms to SomeProtocol, but, I'm getting this error when trying to pass the method as argument for that generic function: "Static member 'currency' cannot be used on protocol metatype 'SomeProtocol.Type'".

I'm just trying to recreate this SwiftUI code:

Text(20.0, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))

Reading the documentation, the function from above is a generic init() that takes a generic type that conforms to some protocols.

init<F>(_ input: F.FormatInput, format: F) where F : FormatStyle, F.FormatInput : Equatable, F.FormatOutput == String

So, .currency() is a static method that comes from FloatingPointFormatStyle.Currency, a structthat conforms to FormatStyle.

My question is, why is this working in SwiftUI (passing a static method from a struct that conforms to a protocol as an argument to a function that accepts any type that conforms to that protocol) but is not in my own example:

protocol SomeProtocol {
    associatedtype SomeType: SomeProtocol
    var a: String { get }
    var b: String { get }
    static func currency(x: Int) -> SomeType
}

func someTest<T>(x: T) -> String where T: SomeProtocol{
    return "this works!"
}

struct AnotherType: SomeProtocol {
    let a = "Test"
    let b = "someTest"

    static func currency(x: Int) -> AnotherType {
        return AnotherType()
    }
}

someTest(x: .currency(x: 20))

Note that .currency(...) is an implicit member expression.

> An implicit member expression is an abbreviated way to access a member of a type, such as an enumeration case or a type method, in a context where type inference can determine the implied type.

Swift only knows that the parameter x expects some SomeProtocol type, but doesn't know which one. So it thinks that you mean:

someTest(x: SomeProtocol.currency(x: 20))

This is invalid. Which implementation's currency are you calling? The currency method declared in SomeProtocol has no implementation!

You can only call currency on specific implementations of the protocol, e.g. AnotherType.currency(x: 20).

Notice that the documentation for the builtin currency doesn't say anything like "Required", or "Default implementation provided". What SwiftUI does is make an extension of the protocol that contains the implementation of currency, instead of making a protocol requirement:

extension SomeProtocol {
    static func currency(x: Int) -> AnotherType {
        return AnotherType()
    }
}

But this is still not enough though. You still cannot do SomeProtocol.currency(...). What if currency uses some static requirements of the protocol? Swift doesn't know whether there is any, or whether currency uses them.

So you actually need:

extension SomeProtocol where Self == AnotherType {
    static func currency(x: Int) -> AnotherType {
        return AnotherType()
    }
}

Now Swift knows that .currency(x: 20) means AnotherType.currency(x: 20).

Note that the SomeType associated type is unnecessary. You can add further constraints involving that if you want, but it is not necessary for this kind of implicit member expression to work.