Qu'est-ce que le "lifting" en Haskell ?

Question

Je ne comprends pas ce qu'est le "levage". Dois-je d'abord comprendre les monades avant de comprendre ce qu'est une "levée" ? (Je suis aussi complètement ignorant des monades :) Ou quelqu'un peut-il me l'expliquer avec des mots simples ?

Answer 1

La levée est plus un modèle de conception qu'un concept mathématique (bien que je m'attende à ce que quelqu'un ici me réfute en montrant que les levées sont une catégorie ou autre).

Typiquement, vous avez un certain type de données avec un paramètre. Quelque chose comme

data Foo a = Foo { ...stuff here ...}

Supposons que vous trouvez que beaucoup d'utilisations de Foo prennent des types numériques ( Int , Double etc.) et vous devez sans cesse écrire du code qui déballe ces nombres, les ajoute ou les multiplie, puis les emballe à nouveau. Vous pouvez court-circuiter ce processus en n'écrivant qu'une seule fois le code de déballage et d'enroulement. Cette fonction est traditionnellement appelée "ascenseur" car elle ressemble à ceci :

liftFoo2 :: (a -> b -> c) -> Foo a -> Foo b -> Foo c

En d'autres termes, vous avez une fonction qui prend une fonction à deux arguments (comme la fonction (+) ) et le transforme en fonction équivalente pour Foos.

Donc maintenant vous pouvez écrire

addFoo = liftFoo2 (+)

Edit : plus d'informations

Vous pouvez bien sûr avoir liftFoo3 , liftFoo4 et ainsi de suite. Cependant, cela n'est souvent pas nécessaire.

Commencez par l'observation

liftFoo1 :: (a -> b) -> Foo a -> Foo b

Mais c'est exactement la même chose que fmap . Ainsi, plutôt que de liftFoo1 vous écrivez

instance Functor Foo where
   fmap f foo = ...

Si vous voulez vraiment une régularité totale, vous pouvez alors dire

liftFoo1 = fmap

Si vous pouvez faire Foo en un foncteur, peut-être pouvez-vous en faire un foncteur applicatif. En fait, si vous pouvez écrire liftFoo2 alors l'instance applicative ressemble à ceci :

import Control.Applicative

instance Applicative Foo where
   pure x = Foo $ ...   -- Wrap 'x' inside a Foo.
   (<*>) = liftFoo2 ($)

El (<*>) L'opérateur pour Foo a le type

(<*>) :: Foo (a -> b) -> Foo a -> Foo b

Il applique la fonction enveloppée à la valeur enveloppée. Donc, si vous pouvez implémenter liftFoo2 alors vous pouvez écrire ceci en fonction de cela. Ou bien vous pouvez l'implémenter directement et ne pas vous embarrasser de liftFoo2 parce que le Control.Applicative Le module comprend

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

et de même, il y a liftA y liftA3 . Mais vous ne les utilisez pas très souvent car il existe un autre opérateur.

(<$>) = fmap

Cela vous permet d'écrire :

result = myFunction <$> arg1 <*> arg2 <*> arg3 <*> arg4

Le terme myFunction <$> arg1 renvoie une nouvelle fonction enveloppée dans Foo :

ghci> :type myFunction
a -> b -> c -> d

ghci> :type myFunction <$> Foo 3
Foo (b -> c -> d)

Ceci peut à son tour être appliqué à l'argument suivant en utilisant (<*>) et ainsi de suite. Donc maintenant, au lieu d'avoir une fonction de levée pour chaque arité, vous avez juste une chaîne d'applicatifs, comme ceci :

ghci> :type myFunction <$> Foo 3 <*> Foo 4
Foo (c -> d)

ghci: :type myFunction <$> Foo 3 <*> Foo 4 <*> Foo 5
Foo d

Answer 2

Celles de Paul et de Yairchu sont toutes deux de bonnes explications.

J'aimerais ajouter que la fonction levée peut avoir un nombre arbitraire d'arguments et qu'ils ne doivent pas nécessairement être du même type. Par exemple, vous pourriez aussi définir une fonction liftFoo1 :

liftFoo1 :: (a -> b) -> Foo a -> Foo b

En général, la levée des fonctions qui prennent 1 argument est capturée dans la classe de type Functor et l'opération de levage est appelée fmap :

fmap :: Functor f => (a -> b) -> f a -> f b

Notez la similitude avec liftFoo1 Le type de l'entreprise. En fait, si vous avez liftFoo1 vous pouvez faire Foo une instance de Functor :

instance Functor Foo where
  fmap = liftFoo1

De plus, la généralisation de la levée à un nombre arbitraire d'arguments est appelée style applicatif . Ne vous y plongez pas avant d'avoir compris la levée des fonctions avec un nombre fixe d'arguments. Mais quand vous le ferez, Apprenez un Haskell contient un bon chapitre sur ce sujet. Le site Typeclassopedia est un autre bon document qui décrit Fecteur y Applicatif (ainsi que d'autres classes de type ; faites défiler la page jusqu'au chapitre de droite dans ce document).

J'espère que cela vous aidera !

Answer 3

Commençons par un exemple (des espaces blancs ont été ajoutés pour une présentation plus claire) :

> import Control.Applicative
> replicate 3 'a'
"aaa"
> :t replicate
replicate        ::         Int -> b -> [b]
> :t liftA2
liftA2 :: (Applicative f) => (a -> b -> c) -> (f a -> f b -> f c)
> :t liftA2 replicate
liftA2 replicate :: (Applicative f) =>       f Int -> f b -> f [b]
> (liftA2 replicate) [1,2,3] ['a','b','c']
["a","b","c","aa","bb","cc","aaa","bbb","ccc"]
> ['a','b','c']
"abc"

liftA2 transforme une fonction de types ordinaires en une fonction de les mêmes types enveloppés dans un Applicative comme des listes, IO etc.

Un autre ascenseur commun est lift de Control.Monad.Trans . Il transforme une action monadique d'une monade en une action d'une monade transformée.

En général, "ascenseur" ascenseurs une fonction/action dans un type "enveloppé" (de sorte que la fonction originale puisse fonctionner "sous l'enveloppe").

La meilleure façon de comprendre cela, ainsi que les monades, etc., et de comprendre pourquoi elles sont utiles, est probablement de coder et de les utiliser. Si vous avez codé quelque chose auparavant et que vous pensez que cela pourrait vous être utile (par exemple, cela rendra le code plus court, etc.), essayez-le et vous comprendrez facilement le concept.

Answer 4

Le lifting est un concept qui permet de transformer une fonction en une fonction correspondante dans un autre cadre (généralement plus général).

jeter un coup d'œil à http://haskell.org/haskellwiki/Lifting

Answer 5

Selon ce tutoriel brillant un foncteur est un conteneur (comme Maybe<a> , List<a> o Tree<a> qui peut stocker des éléments d'un autre type, a ). J'ai utilisé la notation générique de Java, <a> pour le type d'élément a et pensez aux éléments comme à des baies sur l'arbre. Tree<a> . Il existe une fonction fmap qui prend une fonction de conversion d'éléments, a->b et conteneur functor<a> . Il s'applique a->b à chaque élément du conteneur, le convertissant effectivement en functor<b> . Lorsque seul le premier argument est fourni, a->b , fmap attend le functor<a> . C'est-à-dire qu'il faut fournir a->b seule transforme cette fonction de niveau élémentaire en la fonction functor<a> -> functor<b> qui fonctionne sur des conteneurs. Il s'agit de levage de la fonction. Comme le conteneur est également appelé un foncteur le recours aux foncteurs plutôt qu'aux monades est une condition préalable à la levée. Les monades sont en quelque sorte "parallèles" au lifting. Les deux reposent sur la notion de foncteur et font f<a> -> f<b> . La différence est que le levage utilise a->b pour la conversion, alors que Monad nécessite que l'utilisateur définisse a -> f<b> .