web-dev-qa-db-fra.com

Typealias génériques dans Swift

En haskell vous pouvez faire ceci:

type Parser a = String -> [(a, String)]

J'ai essayé de faire quelque chose de similaire dans Swift. Jusqu'à présent, j'ai écrit ces codes sans succès.

typealias Parser<A> = String -> [(A, String)]
typealias Parser a = String -> [(a, String)]
typealias Parser = String -> [(A, String)]

Alors, est-ce simplement impossible en quick? Et si c'est le cas, existe-t-il un autre moyen de mettre en œuvre ce comportement?

UPDATE: Il semble que les typealias génériques soient maintenant supportés dans Swift 3 https://github.com/Apple/Swift/blob/master/CHANGELOG.md

swiftgenerics
46
mustafa

typealias ne peut actuellement pas être utilisé avec des génériques. Votre meilleure option pourrait être d’envelopper la fonction d’analyseur dans une structure.

 struct Parser<A> {
     let f: String -> [(A, String)]
 }

Vous pouvez ensuite utiliser la syntaxe de fermeture finale lors de la création d'un analyseur syntaxique, par exemple.

let parser = Parser<Character> { string in return [head(string), tail(string)] }
35
Ivica M.

typealias générique peut être utilisé depuis Swift 3.0. Cela devrait fonctionner pour vous:

typealias Parser<A> = (String) -> [(A, String)]

Voici la documentation complète: https://developer.Apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//Apple_ref/Swift/grammar/typealias-declaration

Utilisation (commentaire de @Calin Drule):

func parse<A>(stringToParse: String, parser: Parser)
34
strannik

Ici, je présente un exemple pour typealias qui vous démontrent comment utiliser typealias dans les définitions de protocoles: j’espère que cela vous aidera à comprendre typealias

protocol NumaricType {
typealias elementType
func plus(lhs : elementType, _ rhs : elementType) -> elementType
func minus(lhs : elementType, _ rhs : elementType) -> elementType
 }


struct Arthamatic :NumaricType {

func addMethod(element1 :Int, element2 :Int) -> Int {
   return plus(element1, element2)
}
func minusMethod(ele1 :Int, ele2 :Int) -> Int {
    return minus(ele1, ele2)
}

typealias elementType = Int

func plus(lhs: elementType,  _ rhs: elementType) -> elementType {
    return lhs + rhs
}
func minus(lhs: elementType, _ rhs: elementType) -> elementType {
    return lhs - rhs
 }
}

Sortie:

     let obj =  Arthamatic().addMethod(34, element2: 45) // 79
0
Narendra G