Envelopper des séquences dans Swift

Bonjour à tous. Aujourd'hui, nous voulons partager la traduction préparée à la veille du lancement du cours «Développeur iOS. Cours avancé . " C'est parti!

L'un des principaux avantages de la conception basée sur le protocole de Swift est qu'il nous permet d'écrire du code générique compatible avec un large éventail de types et non spécifiquement implémenté pour tout le monde. Surtout si un tel code général est destiné à l'un des protocoles, qui peut être trouvé dans la bibliothèque standard, ce qui permettra de l'utiliser à la fois avec les types intégrés et ceux définis par l'utilisateur.

Un exemple d'un tel protocole est Sequence, qui est accepté par tous les types de bibliothèques standard qui peuvent être itérées, comme Array, Dictionary, Set et bien d'autres. Cette semaine, voyons comment nous pouvons encapsuler Sequence dans des conteneurs universels, ce qui nous permettra d'encapsuler divers algorithmes au cœur des API faciles à utiliser.

L'art d'être paresseux

Il est assez facile de se perdre en pensant que toutes les séquences sont similaires à Array, car tous les éléments sont instantanément chargés en mémoire lorsque la séquence est créée. Étant donné que la seule exigence du protocole de séquence est que les récepteurs doivent être capables d'itérer, nous ne pouvons faire aucune hypothèse sur la façon dont les éléments d'une séquence inconnue sont chargés ou stockés.
Par exemple, comme nous l'avons vu dans Séquences rapides: l'art d'être paresseux , les séquences peuvent parfois charger leurs éléments paresseusement - soit pour des raisons de performances, soit parce qu'il n'est pas garanti que la séquence entière puisse tenir en mémoire. Voici quelques exemples de telles séquences:

//   ,          ,           . let records = database.records(matching: searchQuery) //     ,       ,      . let folders = folder.subfolders //   ,     ,            . let nodes = node.children 

Étant donné que toutes les séquences ci-dessus sont paresseuses pour une raison quelconque, nous ne voudrions pas les forcer dans un tableau, par exemple, en appelant Array (folder.subfolders). Mais nous pouvons toujours vouloir les modifier et les utiliser de différentes manières, alors regardons comment nous pouvons le faire en créant un type d'encapsuleur de séquence.

Création de fondation

Commençons par créer un type de base que nous pouvons utiliser pour créer toutes sortes d'API pratiques au-dessus de n'importe quelle séquence. Nous l'appellerons WrappedSequence, et ce sera un type universel contenant à la fois le type de la séquence que nous encapsulons et le type d'élément que nous voulons que notre nouvelle séquence crée.
La principale caractéristique de notre wrapper sera sa fonction IteratorFunction, qui nous permettra de prendre le contrôle de la recherche de la séquence de base - en changeant l'itérateur utilisé pour chaque itération:

 struct WrappedSequence<Wrapped: Sequence, Element>: Sequence { typealias IteratorFunction = (inout Wrapped.Iterator) -> Element? private let wrapped: Wrapped private let iterator: IteratorFunction init(wrapping wrapped: Wrapped, iterator: @escaping IteratorFunction) { self.wrapped = wrapped self.iterator = iterator } func makeIterator() -> AnyIterator<Element> { var wrappedIterator = wrapped.makeIterator() return AnyIterator { self.iterator(&wrappedIterator) } } } 

Comme vous pouvez le voir ci-dessus, Sequence utilise un modèle d'usine de sorte que chaque séquence crée une nouvelle instance d'itérateur pour chaque itération - en utilisant la méthode makeIterator ().

Ci-dessus, nous utilisons le type AnyIterator de la bibliothèque standard, qui est un itérateur d'effacement de type qui peut utiliser n'importe quelle implémentation IteratorProtocol de base pour obtenir les valeurs des éléments. Dans notre cas, nous allons créer un élément en appelant notre IteratorFunction, en passant comme argument notre propre itérateur de la séquence encapsulée, et puisque cet argument est marqué comme inout, nous pouvons changer l'itérateur de base en place à l'intérieur de notre fonction.

Étant donné que WrappedSequence est également une séquence, nous pouvons utiliser toutes les fonctionnalités de la bibliothèque standard qui lui sont associées, telles que l'itérer dessus ou transformer ses valeurs à l'aide de la carte:

 let folderNames = WrappedSequence(wrapping: folders) { iterator in return iterator.next()?.name } for name in folderNames { ... } let uppercasedNames = folderNames.map { $0.uppercased() } 

Commençons maintenant avec notre nouvelle WrappedSequence!

Préfixes et suffixes

Lorsque vous travaillez très souvent avec des séquences, vous souhaitez insérer un préfixe ou un suffixe dans la séquence avec laquelle nous travaillons - mais ne serait-il pas formidable de pouvoir le faire sans changer la séquence principale? Cela peut conduire à de meilleures performances et nous permet d'ajouter des préfixes et suffixes à n'importe quelle séquence, et pas seulement des types généraux tels que Array.

En utilisant WrappedSequence, nous pouvons le faire assez facilement. Tout ce que nous devons faire est d'étendre Sequence avec une méthode qui crée une séquence encapsulée à partir d'un tableau d'éléments à insérer comme préfixe. Ensuite, lorsque nous répétons, nous commençons à itérer sur tous les éléments de préfixe avant de continuer avec la séquence de base - comme ceci:

 extension Sequence { func prefixed( with prefixElements: Element... ) -> WrappedSequence<Self, Element> { var prefixIndex = 0 return WrappedSequence(wrapping: self) { iterator in //        ,   ,   ,   : guard prefixIndex >= prefixElements.count else { let element = prefixElements[prefixIndex] prefixIndex += 1 return element } //           : return iterator.next() } } } 

Ci-dessus, nous utilisons un paramètre avec un nombre variable d'arguments (en ajoutant ... à son type) pour permettre la transmission d'un ou plusieurs éléments à la même méthode.
De la même manière, nous pouvons créer une méthode qui ajoute un ensemble donné de suffixes à la fin de la séquence - d'abord en effectuant notre propre itération de la séquence de base, puis en itérant sur les éléments suffixés:

 extension Sequence { func suffixed( with suffixElements: Element... ) -> WrappedSequence<Self, Element> { var suffixIndex = 0 return WrappedSequence(wrapping: self) { iterator in guard let next = iterator.next() else { //    ,     nil      : guard suffixIndex < suffixElements.count else { return nil } let element = suffixElements[suffixIndex] suffixIndex += 1 return element } return next } } } 

Avec les deux méthodes mentionnées ci-dessus, nous pouvons maintenant ajouter des préfixes et des suffixes à n'importe quelle séquence que nous voulons. Voici quelques exemples d'utilisation de nos nouvelles API:

 //      : let allFolders = rootFolder.subfolders.prefixed(with: rootFolder) //       : let messages = inbox.messages.suffixed(with: composer.message) //       ,      : let characters = code.prefixed(with: "{").suffixed(with: "}") 

Bien que tous les exemples ci-dessus puissent être implémentés à l'aide de types spécifiques (tels que Array et String), l'avantage d'utiliser notre type WrappedSequence est que tout peut être fait paresseusement - nous n'effectuons aucune mutation ni n'évaluons aucune séquence pour ajouter notre préfixes ou suffixes - qui peuvent être très utiles dans des situations critiques pour les performances ou lorsque vous travaillez avec de grands ensembles de données.

Segmentation

Ensuite, voyons comment nous pouvons encapsuler des séquences pour en créer des versions segmentées. Dans certaines itérations, il ne suffit pas de savoir ce qu'est l'élément actuel - nous pouvons également avoir besoin d'informations sur les éléments suivants et précédents.
Lorsque vous travaillez avec des séquences indexées, nous pouvons souvent y parvenir en utilisant l'API énumérée (), qui utilise également un wrapper de séquence pour nous donner accès à la fois à l'élément actuel et à son index:

 for (index, current) in list.items.enumerated() { let previous = (index > 0) ? list.items[index - 1] : nil let next = (index < list.items.count - 1) ? list.items[index + 1] : nil ... } 

Cependant, la technique ci-dessus n'est pas seulement assez verbeuse en termes d'invocation, elle repose également sur l'utilisation de tableaux à nouveau - ou au moins d'une forme de séquence qui nous donne un accès aléatoire à ses éléments - que de nombreuses séquences, en particulier les paresseuses pas la bienvenue.
À la place, utilisons à nouveau notre WrappedSequence - pour créer un encapsuleur de séquence qui fournit paresseusement des vues segmentées dans sa séquence de base, en suivant les éléments précédents et actuels et en les mettant à jour au fur et à mesure de son itération:

 extension Sequence { typealias Segment = ( previous: Element?, current: Element, next: Element? ) var segmented: WrappedSequence<Self, Segment> { var previous: Element? var current: Element? var endReached = false return WrappedSequence(wrapping: self) { iterator in //        ,      ,   ,        ,     . guard !endReached, let element = current ?? iterator.next() else { return nil } let next = iterator.next() let segment = (previous, element, next) //     ,    ,      : previous = element current = next endReached = (next == nil) return segment } } } 

Maintenant, nous pouvons utiliser l'API ci-dessus pour créer une version segmentée de n'importe quelle séquence chaque fois que nous devons regarder en avant ou en arrière lors d'une itération. Par exemple, voici comment nous pouvons utiliser la segmentation afin que nous puissions facilement déterminer quand nous avons atteint la fin de la liste:

 for segment in list.items.segmented { addTopBorder() addView(for: segment.current) if segment.next == nil { //   ,     addBottomBorder() } } ```swift        ,   .    ,               : ```swift for segment in path.nodes.segmented { let directions = ( enter: segment.previous?.direction(to: segment.current), exit: segment.next.map(segment.current.direction) ) let nodeView = NodeView(directions: directions) nodeView.center = segment.current.position.cgPoint view.addSubview(nodeView) } 

Nous commençons maintenant à voir la véritable puissance des séquences d'encapsulation - en ce sens qu'elles nous permettent de masquer des algorithmes de plus en plus complexes dans une API vraiment simple. Tout ce dont l'appelant a besoin pour segmenter la séquence, c'est accéder à la propriété segmentée dans n'importe quelle séquence, et notre implémentation de base se chargera du reste.

Récursivité

Enfin, regardons comment même les itérations récursives peuvent être modélisées à l'aide d'encapsuleurs de séquence. Supposons que nous voulions fournir un moyen simple d'itérer récursivement une hiérarchie de valeurs dans laquelle chaque élément de la hiérarchie contient une séquence d'éléments enfants. Il peut être assez difficile de le faire correctement, donc ce serait génial si nous pouvions utiliser une implémentation pour effectuer toutes ces itérations dans notre base de code.
En utilisant WrappedSequence, nous pouvons y parvenir en étendant Sequence avec une méthode qui utilise la même contrainte de type générique pour garantir que chaque élément peut fournir une séquence imbriquée qui a le même type d'itérateur que notre original. Pour pouvoir accéder dynamiquement à chaque séquence imbriquée, nous demanderons également à l'appelant de spécifier KeyPath pour la propriété qui doit être utilisée pour la récursivité, ce qui nous donnera une implémentation qui ressemble à ceci:

 extension Sequence { func recursive<S: Sequence>( for keyPath: KeyPath<Element, S> ) -> WrappedSequence<Self, Element> where S.Iterator == Iterator { var parentIterators = [Iterator]() func moveUp() -> (iterator: Iterator, element: Element)? { guard !parentIterators.isEmpty else { return nil } var iterator = parentIterators.removeLast() guard let element = iterator.next() else { //          ,    ,      : return moveUp() } return (iterator, element) } return WrappedSequence(wrapping: self) { iterator in //       ,      ,      : let element = iterator.next() ?? { return moveUp().map { iterator = $0 return $1 } }() //       ,  ,         ,         . if let nested = element?[keyPath: keyPath].makeIterator() { let parent = iterator parentIterators.append(parent) iterator = nested } return element } } } 

En utilisant ce qui précède, nous pouvons maintenant itérer récursivement sur n'importe quelle séquence, quelle que soit la façon dont elle est construite à l'intérieur, et sans avoir à charger la hiérarchie entière à l'avance. Par exemple, voici comment nous pourrions utiliser cette nouvelle API pour parcourir récursivement une hiérarchie de dossiers:

 let allFolders = folder.subfolders.recursive(for: \.subfolders) for folder in allFolders { try loadContent(from: folder) } 

Nous pouvons également l'utiliser pour itérer sur tous les nœuds de l'arborescence ou pour parcourir récursivement un ensemble d'enregistrements de base de données - par exemple, pour répertorier tous les groupes d'utilisateurs dans une organisation:

 let allNodes = tree.recursive(for: \.children) let allGroups = database.groups.recusive(for: \.subgroups) 

Une chose que nous devons être prudents lorsqu'il s'agit d'itérations récursives est d'empêcher les références circulaires - lorsqu'un certain chemin nous ramène à un élément que nous avons déjà rencontré - qui nous mènera à une boucle infinie.
Une façon de résoudre ce problème est de garder une trace de tous les éléments qui se produisent (mais cela peut être problématique d'un point de vue mémoire), de s'assurer qu'il n'y a pas de références circulaires dans notre ensemble de données, ou de gérer de tels cas à chaque fois du côté de l'appel (en utilisant break, continue ou return pour terminer tout itérations cycliques).

Conclusion

La séquence est l'un des protocoles les plus simples de la bibliothèque standard - elle ne nécessite qu'une seule méthode - mais elle est toujours l'une des plus puissantes, en particulier en ce qui concerne la quantité de fonctionnalités que nous pouvons créer en fonction de celle-ci. Tout comme la bibliothèque standard contient des séquences d'encapsuleur pour des choses comme les énumérations, nous pouvons également créer nos propres encapsuleurs - qui nous permettent de masquer des fonctionnalités avancées avec des API vraiment simples.

Bien que les abstractions aient toujours un prix, il est important de considérer quand cela vaut la peine (et peut-être plus important encore quand elles n'en valent pas la peine) de les introduire, si nous pouvons construire nos abstractions directement en plus de ce que la bibliothèque standard fournit - en utilisant les mêmes conventions - alors ces les abstractions sont généralement plus susceptibles de résister à l'épreuve du temps.