0Pricing
Swift Academy · Leçon

Contraintes récursives et génériques d’ordre supérieur

Écrivez des contraintes récursives (par exemple, des séquences imbriquées) et des fonctions génériques d’ordre supérieur qui acceptent des fermetures ou fonctions génériques.

Contraintes récursives et génériques d’ordre supérieur est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 3 leçons au total.

Quoi et pourquoi

Cette leçon présente :

  • Contraintes récursives : des contraintes sur des membres génériques imbriqués, par exemple une séquence de séquences.
  • Génériques d’ordre supérieur : des fonctions génériques qui acceptent des fermetures ou fonctions génériques.

Séquences imbriquées (flatten)

Voici un exemple classique de contrainte récursive : nous exigeons C.Element: Sequence afin de pouvoir parcourir deux niveaux d’imbrication.

// Works for any Collection whose elements are Sequences
func flatten<C: Collection>(_ c: C) -> [C.Element.Element]
where C.Element: Sequence {
    var result: [C.Element.Element] = []
    result.reserveCapacity(c.reduce(0) { $0 + ($1 as AnySequence<C.Element.Element>).underestimatedCount })
    for inner in c {
        for e in inner { result.append(e) }
    }
    return result
}
let nested = [[1,2], [3], [4,5]]
print(flatten(nested))  // [1,2,3,4,5]

Transformer des séquences imbriquées de manière générique

Nous imposons deux contraintes : C: Collection et C.Element: Collection, ce qui nous permet d’appeler map à chaque niveau.

// Map over a two-level structure without fixing concrete types
func mapNested<C: Collection, R>(_ c: C, _ transform: (C.Element.Element) -> R) -> [[R]]
where C.Element: Collection {
    return c.map { inner in inner.map(transform) }
}
let doubled = mapNested([[1,2],[3]], { $0 * 2 })
print(doubled) // [[2,4],[6]]

compose(f,g)

Génériques d’ordre supérieur : la fonction est générique jusque dans les fonctions elles-mêmes, ce qui permet de créer des chaînes de traitement réutilisables comme compose.

// Compose two generic transforms that work on the same element type
func compose<A, B, C>(
    _ f: @escaping (B) -> C,
    _ g: @escaping (A) -> B
) -> (A) -> C {
    { a in f(g(a)) }
}
let toString: (Int) -> String = { "\\($0)" }
let length: (String) -> Int = { $0.count }
let intToLen = compose(length, toString)
print(intToLen(1234))  // 4

Paramètres de fermeture génériques

La fermeture f est elle aussi un paramètre générique. Nous conservons des types flexibles grâce à des contraintes conditionnelles.

// A generic "transform each" that accepts ANY transform (generic in T/U)
func transformEach<T, U, C: Collection>(_ c: C, using f: (T) -> U) -> [U]
where C.Element == T {
    var out: [U] = []
    out.reserveCapacity(c.count)
    for x in c { out.append(f(x)) }
    return out
}
let words = ["swift","kit"]
print(transformEach(words, using: { $0.uppercased() })) // ["SWIFT","KIT"]

Recommandations

Conseils :

  • Écrivez uniquement les contraintes nécessaires, Sequence plutôt que Collection, par exemple.
  • Préférez les clauses conditionnelles pour améliorer la lisibilité.
  • Testez avec plusieurs types concrets pour garantir la généralité.
  • Documentez les hypothèses, comme l’ordre des éléments ou leur unicité.

Définition des génériques d’ordre supérieur

Vérification rapide : qu’est-ce qui fait d’une fonction une fonction générique d’ordre supérieur ?

Récapitulatif

Récapitulatif : utilisez des contraintes récursives, par exemple C.Element: Sequence, pour travailler avec des génériques imbriqués ; utilisez les génériques d’ordre supérieur pour composer proprement des chaînes de traitement réutilisables.

Questions Fréquemment Posées

La leçon « Contraintes récursives et génériques d’ordre supérieur » est-elle gratuite ?

Oui — le texte complet de « Contraintes récursives et génériques d’ordre supérieur » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Contraintes récursives et génériques d’ordre supérieur » ?

Écrivez des contraintes récursives (par exemple, des séquences imbriquées) et des fonctions génériques d’ordre supérieur qui acceptent des fermetures ou fonctions génériques. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Contraintes récursives et génériques d’ordre supérieur » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Conformités conditionnelles
  2. Contraintes récursives et génériques d’ordre supérieur
  3. Clauses where sur les extensions
← Retour à Swift Academy