Ограничить ассоциированный тип

Question

упрощенная версия моего кода, который показывает проблему:

protocol Transformer { 
    typealias Input 
    typealias Output 

    func transform(s: Input) -> Output 
} 

protocol InputType {} 
protocol OutputType {} 

extension Int: OutputType {} 
extension String: InputType {} 

struct StringToInt: Transformer { 
    typealias Input = String 
    typealias Output = Int 

    func transform(s: Input) -> Output { 
     return s.characters.count 
    } 
} 

typealias Transform = InputType -> OutputType 

func convert<T: Transformer where T.Input == InputType, T.Output == OutputType> 
    (transformer: T) -> Transform { 
    return transformer.transform 
} 

convert(StringToInt()) // error: Cannot invoke 'convert' with an argument list of type '(StringToInt)' 

Я предполагаю, что ошибка происходит потому, что компилятор не может достичь в StringToInt и убедитесь, что Input и Output действительно соответствуют InputType и OutputType соответственно.

Для меня лучшим способом решить эту проблему было бы ограничение связанных типов непосредственно в протоколе. Это было бы более выразительно, и у компилятора была бы больше информации. Но просто делать typealias Input: InputType не работает.

Есть ли способ ограничить связанный тип?

Answer 1

Вы можете создать расширение для Transformer протокола

extension Transformer where Input: InputType, Output: OutputType { 
    func convert() -> Input -> Output { 
     return transform 
    } 
} 

Теперь вы можете вызвать метод convert на StringToInt инстанции.

StringToInt().convert() 

Но для другого типа, который не имеет Input и Output принятия InputType и OutputType не будет компилировать

struct DoubleToFloat: Transformer { 
    func transform(s: Double) -> Float { 
     return Float(s) 
    } 
} 

DoubleToFloat().convert() // compiler error 

Answer 2

Избавиться от использования в Transform псевдоним, добавьте генерики входа и выведите их на Transformer, и вы получите рабочий код для StringToInt и для других трансформаторов, которые вы пишете:

func convert<T: Transformer, I, O where T.Input == I, T.Output == O> 
    (transformer: T) -> I -> O { 
     return transformer.transform 
} 

convert(StringToInt()) 

Кстати, вам не нужно указывать псевдонимы типа для StringToInt, компилятор может сделать вывод о тех, из определения функции, если указать фактические типы:

struct StringToInt: Transformer { 

    func transform(s: String) -> Int { 
     return s.characters.count 
    } 
}