Tenho problemas com o seguinte código:

func generic1<T>(name : String){
}

func generic2<T>(name : String){
     generic1<T>(name)
}

o resultado genérico1 (nome) para erro do compilador "Não é possível especializar explicitamente uma função genérica"

Existe alguma maneira de evitar esse erro? Não posso alterar a assinatura da função genérica1, portanto, deve ser (String) -> Void

Eu também tive esse problema e encontrei uma solução alternativa para o meu caso.

Neste artigo o autor tem o mesmo problema

https://www.iphonelife.com/blog/31369/swift-programming-101-generics-practical-guide

Portanto, o problema parece ser que o compilador precisa inferir o tipo de T de alguma forma. Mas não é permitido simplesmente usar <type> genérico (params ...).

Normalmente, o compilador pode procurar o tipo de T, examinando os tipos de parâmetro porque é onde T é usado em muitos casos.

No meu caso foi um pouco diferente, porque o tipo de retorno da minha função era T. No seu caso, parece que você não usou T em sua função. Eu acho que você simplificou o código de exemplo.

Portanto, tenho a seguinte função

func getProperty<T>( propertyID : String ) -> T

E no caso de, por exemplo

getProperty<Int>("countProperty")

o compilador me dá o erro:

Não é possível especializar explicitamente uma função genérica

Portanto, para dar ao compilador outra fonte de informação para inferir o tipo de T, você deve declarar explicitamente o tipo da variável em que o valor de retorno é salvo.

var value : Int = getProperty("countProperty")

Dessa forma, o compilador sabe que T deve ser um inteiro.

Portanto, acho que, no geral, significa simplesmente que, se você especificar uma função genérica, terá que usar pelo menos T em seus tipos de parâmetro ou como um tipo de retorno.

Swift 5

Normalmente, existem muitas maneiras de definir funções genéricas. Mas eles são baseados na condição que Tdeve ser usada como um parameter, ou como um return type.

extension UIViewController {
    class func doSomething<T: UIView>() -> T {
        return T()
    }

    class func doSomethingElse<T: UIView>(value: T) {
        // Note: value is a instance of T
    }

    class func doLastThing<T: UIView>(value: T.Type) {
        // Note: value is a MetaType of T
    }
}

Depois disso, devemos fornecer Tao ligar.

let result = UIViewController.doSomething() as UIImageView // Define `T` by casting, as UIImageView
let result: UILabel = UIViewController.doSomething() // Define `T` with property type, as UILabel
UIViewController.doSomethingElse(value: UIButton()) // Define `T` with parameter type, as UIButton
UIViewController.doLastThing(value: UITextView.self) // Define `T` with parameter type, as UITextView

Ref:

1. http://austinzheng.com/2015/01/02/swift-generics-pt-1/
2. https://dispatchswift.com/type-constraints-for-generics-in-swift-d6bf2f0dbbb2

A solução é usar o tipo de classe como parâmetro (como em Java)

Para deixar o compilador saber com que tipo ele está lidando, passe a classe como argumento

extension UIViewController {
    func navigate<ControllerType: UIViewController>(_ dump: ControllerType.Type, id: String, before: ((ControllerType) -> Void)?){
        let controller = self.storyboard?.instantiateViewController(withIdentifier: id) as! ControllerType
        before?(controller)
        self.navigationController?.pushViewController(controller, animated: true)
    }
}

Ligue como:

self.navigate(UserDetailsViewController.self, id: "UserDetailsViewController", before: {
        controller in
        controller.user = self.notification.sender
    })

Você não precisa de uma função genérica aqui, já que tem tipos estáticos (String como parâmetro), mas se quiser que uma função genérica chame outra, você pode fazer o seguinte.

Usando métodos genéricos

func fetchObjectOrCreate<T: NSManagedObject>(type: T.Type) -> T {
    if let existing = fetchExisting(type) {
       return existing
    }
    else {
        return createNew(type)
    }
}

func fetchExisting<T: NSManagedObject>(type: T.Type) -> T {
    let entityName = NSStringFromClass(type)
     // Run query for entiry
} 

func createNew<T: NSManagedObject>(type: T.Type) -> T {
     let entityName = NSStringFromClass(type)
     // create entity with name
} 

Usando uma classe genérica (menos flexível, pois o genérico pode ser definido para 1 tipo apenas por instância)

class Foo<T> {

   func doStuff(text: String) -> T {
      return doOtherStuff(text)
   }

   func doOtherStuff(text: String) -> T {

   }  

}

let foo = Foo<Int>()
foo.doStuff("text")

Eu acho que quando você especifica a função genérica, você deve especificar alguns dos parâmetros do tipo T, como segue:

func generic1<T>(parameter: T) {
    println("OK")
}

func generic2<T>(parameter: T) {
    generic1(parameter)
}

e se quiser chamar o método handle (), você pode fazer isso escrevendo protocolo e especificando a restrição de tipo para T:

protocol Example {
    func handle() -> String
}

extension String: Example {
    func handle() -> String {
        return "OK"
    }
}

func generic1<T: Example>(parameter: T) {
    println(parameter.handle())
}

func generic2<T: Example>(parameter: T) {
    generic1(parameter)
}

então você pode chamar esta função genérica com String:

generic2("Some")

e vai compilar

Até agora, minha melhor prática pessoal usou a resposta de @orkhan-alikhanov. Hoje, quando se olha para SwiftUI e como .modifier()e ViewModifieré implementado, eu encontrei outra maneira (ou é mais uma solução alternativa?)

Basta envolver a segunda função em um struct.

Exemplo:

Se este fornecer a você a mensagem "Não é possível especializar explicitamente uma função genérica"

func generic2<T>(name: String){
     generic1<T>(name)
}

Este pode ajudar. Envolva a declaração de generic1em um struct:

struct Generic1Struct<T> {
    func generic1(name: String) {## do, whatever it needs with T ##}
}

e chamá-lo com:

func generic2<T>(name : String){
     Generic1Struct<T>().generic1(name: name)
}

Observações:

• Não sei se ajuda em algum caso possível, quando essa mensagem de erro ocorrer. Só sei que fiquei preso muitas vezes quando isso surgiu. Eu sei, que esta solução ajudou hoje, quando a mensagem de erro apareceu.
• A maneira como o Swift lida com os genéricos ainda é confusa para mim.
• Este exemplo e a solução alternativa com o structé um bom exemplo. A solução alternativa aqui não tem um pouco mais de informação - mas passa pelo compilador. Mesma informação, mas resultados diferentes? Então algo está errado. Se for um bug do compilador, ele pode ser corrigido.

Tive um problema semelhante com minha função de classe genérica class func retrieveByKey<T: GrandLite>(key: String) -> T?.

Eu não poderia chamá-lo let a = retrieveByKey<Categories>(key: "abc")onde Categories é uma subclasse de GrandLite.

let a = Categories.retrieveByKey(key:"abc")GrandLite retornou, não categorias. As funções genéricas não inferem o tipo com base na classe que as chama.

class func retrieveByKey<T: GrandLite>(aType: T, key: String>) -> T?deu-me um erro quando tentei, let a = Categories.retrieveByKey(aType: Categories, key: "abc")deu-me um erro informando que não foi possível converter Categories.Type em GrandLite, embora Categories seja uma subclasse de GrandLite. CONTUDO...

class func retrieveByKey<T: GrandLite>(aType: [T], key: String) -> T? fez o trabalho se eu tentasse let a = Categories.retrieveByKey(aType: [Categories](), key: "abc"), aparentemente, uma atribuição explícita de uma subclasse não funciona, mas uma atribuição implícita usando outro tipo genérico (array) funciona em Swift 3.