Haskell - Fermetures éclair

Zippers dans Haskell sont essentiellement des pointeurs qui pointent vers un emplacement spécifique d'une structure de données telle qu'un tree.

Considérons un tree ayant 5 éléments [45,7,55,120,56]qui peut être représenté comme un arbre binaire parfait. Si je veux mettre à jour le dernier élément de cette liste, alors je dois parcourir tous les éléments pour atteindre le dernier élément avant de le mettre à jour. Droite?

Mais que se passerait-il si nous pouvions construire notre arbre de telle manière qu'un arbre N elements est une collection de [(N-1),N]. Ensuite, nous n'avons pas besoin de traverser tous les indésirables(N-1)éléments. Nous pouvons directement mettre à jour le Nième élément. C'est exactement le concept de Zipper. Il se concentre ou pointe vers un emplacement spécifique d'un arbre où nous pouvons mettre à jour cette valeur sans parcourir l'arbre entier.

Dans l'exemple suivant, nous avons implémenté le concept de fermeture éclair dans une liste. De la même manière, on peut implémenter Zipper dans untree ou un file Structure de données.

data List a = Empty | Cons a (List a) deriving (Show, Read, Eq, Ord)
type Zipper_List a = ([a],[a])    

go_Forward :: Zipper_List a -> Zipper_List a   
go_Forward (x:xs, bs) = (xs, x:bs)   
   
go_Back :: Zipper_List a -> Zipper_List a   
go_Back (xs, b:bs) = (b:xs, bs)    

main = do 
   let list_Ex = [1,2,3,4] 
   print(go_Forward (list_Ex,[]))       
   print(go_Back([4],[3,2,1]))

Lorsque vous compilez et exécutez le programme ci-dessus, il produira la sortie suivante -

([2,3,4],[1]) 
([3,4],[2,1])

Nous nous concentrons ici sur un élément de la chaîne entière en avançant ou en reculant.