Fonctions génériques

Fait partie de la section Programmation orientée objet du Journey Swift de Coddy. Leçon 34 sur 57.

Une fonction générique fonctionne avec n’importe quel type. Le paramètre fictif entre chevrons, souvent T, représente le type utilisé par l’appelant, et Swift le détermine à chaque appel :

func firstAndLast<T>(_ items: [T]) -> [T] {
    guard let first = items.first, let last = items.last else { return [] }
    return [first, last]
}

print(firstAndLast([3, 8, 1]))
print(firstAndLast(["a", "b", "c"]))

Sortie :

[3, 1]
["a", "c"]

À l’intérieur de la fonction, rien n’est connu à propos de T ; seules les opérations qui fonctionnent pour chaque type sont donc autorisées. Une contrainte telle que T: Comparable permet d’en faire davantage, ici l’opérateur < :

func largest<T: Comparable>(_ items: [T]) -> T? {
    guard var best = items.first else { return nil }
    for item in items where item > best { best = item }
    return best
}

print(largest([4, 9, 2])!)
print(largest(["pear", "apple", "zucchini"])!)

Sortie :

9
zucchini

Les types génériques conservent le type exact, contrairement à Any. Le résultat de largest sur [Int] est un Int?, il peut donc être utilisé dans des opérations arithmétiques sans conversion :

func largest<T: Comparable>(_ items: [T]) -> T? {
    items.max()
}

let top = largest([3, 7, 5]) ?? 0
print(top * 10)

Sortie :

Une fonction peut avoir plusieurs paramètres génériques, et les contraintes peuvent nommer des protocoles que vous définissez vous-même :

protocol Scored { var score: Int { get } }
struct Player: Scored { let name: String; let score: Int }
struct Team: Scored { let score: Int }

func total<T: Scored>(_ items: [T]) -> Int {
    items.reduce(0) { $0 + $1.score }
}

func pair<A, B>(_ a: A, _ b: B) -> String { "\(a) & \(b)" }

print(total([Player(name: "a", score: 3), Player(name: "b", score: 4)]))
print(total([Team(score: 10)]))
print(pair(1, "one"))

Résultat :

7
10
1 & one

Défi

Facile

Écrivez la fonction générique countWhere(_:_:) qui prend un tableau de n’importe quel type ainsi qu’un prédicat (T) -> Bool, et renvoie le nombre d’éléments qui satisfont ce prédicat, ainsi que mostCommon(_:) qui prend un tableau de n’importe quel type Hashable et renvoie son élément le plus fréquent (celui qui apparaît en premier dans le tableau en cas d’égalité des occurrences), ou nil pour un tableau vide.

Le code fourni lit une ligne de mots séparés par des virgules et une ligne de nombres. Il affiche le nombre de mots de plus de 3 caractères, le mot le plus fréquent, le nombre de nombres pairs et le nombre le plus fréquent.

Votre code doit être placé dans Functions.swift. main.swift contient le code fourni pour l’entrée et la sortie et ne peut pas être modifié.

REQUIRED OUTPUT FORMAT: [Your translated content here]

Essayez vous-même

// Code d'entrée/sortie fourni : le garder tel quel
var input: [String] = []
while let line = readLine() { input.append(line) }
let words = input[0].split(separator: ",").map(String.init)
let numbers = input[1].split(separator: ",").map { Int($0)! }
print(countWhere(words) { $0.count > 3 })
print(mostCommon(words) ?? "none")
print(countWhere(numbers) { $0 % 2 == 0 })
print(mostCommon(numbers).map { String($0) } ?? "none")