Swift estensione protocollo di esecuzione con un altro protocollo comune tipo associato

Question

consideri il seguente:

protocol Foo { 
    typealias A 
    func hello() -> A 
} 
protocol FooBar: Foo { 
    func hi() -> A 
} 
extension FooBar { 
    func hello() -> A { 
    return hi() 
    } 
} 

class FooBarClass: FooBar { 
    typealias A = String 
    func hi() -> String { 
    return "hello world" 
    } 
} 

Questo codice compila. Ma se commento la definizione esplicita del tipo associato typealias A = String, allora per qualche ragione, swiftc non riesce a dedurre il tipo.

che sto sentendo questo ha a che fare con due protocolli che condividono lo stesso tipo di associato ma senza un'affermazione diretta attraverso, ad esempio, il tipo di parametrizzazione (tipo forse associato non è potente/abbastanza maturo?), Che lo rende ambiguo per l'inferenza di tipo.

Non sono sicuro che si tratti di un bug/immaturità della lingua, o forse, mi mancano alcune sfumature nell'estensione del protocollo che giustamente portano a questo comportamento.

Qualcuno può far luce su questo?

Answer 1

Per la conformità a detto protocollo è necessario fornire valori espliciti per i tipi associati in un protocollo. Questo può essere realizzato con un duro codifica di un tipo, come hai fatto con typealias A = String, o utilizzando un tipo parametrico come lei ha ricordato, come di seguito:

class FooBarClass<T>: FooBar { 
    typealias A = T 
    ... 
} 

Swift non dedurre il tipo associato da un metodo implementato su il protocollo, in quanto potrebbero esserci ambiguità con più metodi con tipi di mismatching. Questo è il motivo per cui le tipealie devono essere risolte esplicitamente nella tua classe di implementazione.

Answer 2

un'occhiata a questo esempio

protocol Foo { 
    typealias A 
    func hello() -> A 
} 
protocol FooBar: Foo { 
    typealias B 
    func hi() -> B 
} 
extension FooBar { 
    func hello() -> B { 
     return hi() 
    } 
} 

class FooBarClass: FooBar { 
    //typealias A = String 
    func hi() -> String { 
     return "hello world" 
    } 
} 

con i generici

class FooBarClass<T>: FooBar { 
    var t: T? 
    func hi() -> T? { 
     return t 
    } 
} 

let fbc: FooBarClass<Int> = FooBarClass() 
fbc.t = 10 
fbc.hello() // 10 
fbc.hi() // 10