Re: Haskell super expressif ?

Si vraiment tu veux mettre le type sur chaque variable, tu peux:

add (x :: Int) (y :: Int) = x + y
(Cela demande l'extension ScopedTypeVariables)

Si tu y tient aussi, tu peux tout écrire avec des tuples:

add' (x :: Int, y :: Int) = x + y
C'est là que curry et uncurry interviennent:

Prelude> :t add
add :: Int -> Int -> Int
Prelude> :t add'
add' :: (Int, Int) -> Int
Prelude> :t curry add'
curry add' :: Int -> Int -> Int
Prelude> :t uncurry (curry add')
uncurry (curry add') :: (Int, Int) -> Int
Prelude> :t uncurry add
uncurry add :: (Int, Int) -> Int
Prelude> :t curry (uncurry add)
curry (uncurry add) :: Int -> Int -> Int
Trouve le style qui te convient ;)

Maintenant tu demandes :

Une flèche implique une relation de cause à effet, ou une sorte de hiérarchie ; or rien de tel entre x et y, non ?

En fait si. On va disuter un peu plus théorie pour s'amuser. Ce n'est ABSOLUMENT pas utile pour faire du Haskell. La https://fr.wikipedia.org/wiki/Correspondance_de_Curry-Howard établit une relation entre type / implémentation et théorème / preuve. Dit autrement, un type est un théorème et son implémentation une preuve.

Reprenons l'exemple de add :: Int -> Int -> Int. C'est un théorème qui dit "Pour tout Int, pour tout autre Int, alors je peux associer un Int". Et la preuve est une preuve par construction avec la fonction + qui associe un Int à tout couple de deux Int.

Dans le cas précis cela ne sert à rien. D'autant que ce n'est pas tout à fait vrai en Haskell car on peut faire des fonctions non totales (i.e. qui ne marchent pas pour toutes leurs valeurs). Mais cela devient très amusant de lire des signatures de cette manière.

Un autre exemple: Int -> String est une fonction qui "à tout Int, associe une String". La preuve c'est la fonction de conversion vers string.