Qu'est-ce que la banane divisée et la fusion dans la programmation fonctionnelle?
Ces termes ont été mentionnés dans mon cours d'université. Rapide Googling m'a pointé sur certains papiers universitaires, mais je cherche une explication simple.
Même si 2 réponses ont déjà été fournies, je ne pense pas que la "division de la banane" ait été expliquée ici.
Il est en effet défini dans "la programmation fonctionnelle avec des bananes, des lentilles, des enveloppes et des fil de fer, Erik Meijer Maarten Fokkinga, Ross Paterson, 1991"; Cet article est difficile à lire (pour moi) en raison de sa forte utilisation de Squiggol. Cependant, "un didacticiel sur l'universalité et l'expressivité du pli, Graham Hutton, 1999" contient une définition plus facile à analyser:
Comme un premier premier exemple de l'utilisation de pli Pour générer des tuples, envisagez la fonction SumLength qui calcule le SUM et longueur d'une liste de chiffres:
sumlength :: [Int] → (Int,Int) sumlength xs = (sum xs, length xs)Par une combinaison simple des définitions des fonctions somme et longueur Utilisation pliez donné plus tôt, la fonction sumlength Peut être redéfini comme une seule application de pli qui génère une paire de nombres à partir d'une liste de nombres:
sumlength = fold (λn (x, y) → (n + x, 1 + y)) (0, 0)Cette définition est plus efficace que la définition initiale, car elle ne fait qu'une seule traversée sur la liste des arguments, plutôt que deux traversers distincts. Généralisant à partir de cet exemple, toute paire d'applications de pli à la même liste peut toujours être combinée pour donner une seule application de pli qui génère une paire, par En appelant à la propriété dite "Banana Split" de Plier (Meijer, 1992). Le nom étrange de cette propriété découle du fait que le pli L'opérateur est parfois écrit à l'aide de supports (| |) qui ressemble à des bananes et que l'opérateur de jumelage est parfois appelé divisé. Par conséquent, leur combinaison peut être appelée une banane scission!
Donc, cela est en fait une référencée à un papier de Meijer et quelques autres appelées " programmation fonctionnelle avec bananes, objectifs, enveloppes et fil de fer barbelé ", l'idée de base est que nous pouvons prendre tout type de données récursif, comme dire
data List = Cons Int List | Nil
et nous pouvons prendre en compte la récursion dans une variable de type
data ListF a = Cons Int a | Nil
la raison pour laquelle j'ai ajouté que F est parce que c'est maintenant un ameublement! Il nous permet également de imiter des listes, mais avec une torsion: pour créer des listes, nous devons nier le type de liste.
type ThreeList = ListF (ListF (ListF Void)))
Pour récupérer notre liste d'origine, nous devons continuer à imbriquer ceci infiniment . Cela nous donnera un type ListFF où
ListF ListFF == ListFF
Pour ce faire, définissez un "type de point fixe"
data Fix f = Fix {unfix :: f (Fix f)}
type ListFF = Fix ListF
En tant qu'exercice, vous devriez vérifier que cela satisfait notre équation ci-dessus. Nous pouvons enfin définir ce que les bananes (catamorphismes) sont!
type ListAlg a = ListF a -> a
ListAlgs sont le type de "liste algébras", et nous pouvons définir une fonction particulière
cata :: ListAlg a -> ListFF -> a
cata f = f . fmap (cata f) . unfix
En outre
cata :: ListAlg a -> ListFF -> a
cata :: (Either () (Int, a) -> a) -> ListFF -> a
cata :: (() -> a) -> ((Int, a) -> a) -> ListFF -> a
cata :: a -> (Int -> a -> a) -> ListFF -> a
cata :: (Int -> a -> a) -> a -> [Int] -> a
Semble familier? cata est précisément la même chose que les plis droit!
Ce qui est vraiment intéressant, c'est que nous pouvons le faire sur plus de seulement des listes, tout type défini avec ce "point fixe d'un foncteur" a un cata et pour les accueillir tout ce qu'il suffit de détendre la signature de type
cata :: (f a -> a) -> Fix f -> a
Ceci est effectivement inspiré d'un morceau de théorie de catégorie qui j'ai écrit environ , mais c'est la viande du côté Haskell.
Bien que Jozefg ait fourni une réponse, je ne suis pas sûr que cela réponde à la question. La "loi sur la fusion" est expliquée dans le document suivant:
Un tutoriel sur l'universalité et l'expressivité du pli, Graham Hutton, 1999
Fondamentalement, il dit que dans certaines conditions, vous pouvez combiner ("fusible") la composition d'une fonction et plier en un seul pli, donc fondamentalement
h · pli g w = pli f v
Les conditions de cette égalité sont
h w = v
[.____] H (g x y) = f x (h y)
La "Split banane" ou "Law Split Banana" est de l'article
Programmation fonctionnelle avec bananes, objectifs, enveloppes et fil barbelé, Erik Meijer Maarten Fokkinga, Ross Paterson, 1991
Malheureusement, l'article est très difficile à déchiffrer, car il utilise le formalisme des oiseaux-Meertens, donc je ne pouvais pas faire la tête ni la queue. Autant que j'ai compris la "loi sur la division de la banane", il dit que si vous avez 2 plis opérant sur le même argument, ils peuvent être fusionnés en un seul pli.