2010-11-25 25 views
1

Quelqu'un peut-il me expliquer, pourquoi ces fonctions ont différents nombre d'arguments et le comportement, mais la signature même type , mais ils sont à la fois correcte?haskell question de la signature de type

comp1 :: (a -> b) -> (b -> c) -> a -> c 
comp1 f g = g.f 

comp2 :: (a -> b) -> (b -> c) -> a -> c 
comp2 f g x = g (f x) 

aussi, pourquoi COMP2 a

comp2 :: (a -> b) -> (b -> c) -> a -> c 

au lieu de quelque chose comme

comp2 :: a -> (a -> b) -> (b -> c) -> a -> c 

?

Merci.

+2

http://www.haskell.org/haskellwiki/Eta_conversion? –

+3

De quelle manière les deux fonctions ont-elles un comportement différent? Ça me ressemble ... – sepp2k

Répondre

4
comp2 f g x = g (f x) 

est le sucre syntaxique pour

comp2 = \f -> \g -> \x -> g (f x) 

De même

comp1 f g = g.f 

est le sucre pour

comp1 = \f -> \g -> g.f 

La définition de . est:

f1 . f2 = \x -> f1 (f2 x) -- Names of arguments have been changed to avoid confusion 

Donc, si l'on insère la définition dans la forme Dessucré de comp1, nous obtenons:

comp1 = \f -> \g -> \x -> g (f x) 

C'est exactement la même que la forme Dessucré de comp2, si clairement les définitions sont équivalentes.

4

comp1 f g = g.f est écrit en point-free style (ne fait pas référence aux points, mais à valeurs). Lorsque vous appelez comp1, il est implicitement un troisième paramètre étant passé à g.f, qui est la composition des deux fonctions g et f: (g.f) x égal g (f x), à savoir g est passé le résultat de f x. Aucun paramètre x n'existe dans comp1 car il est implicitement transmis à la fonction. (Vous pourriez penser comp1 comme partiellement appliqué ou cari fonction si elle vous fait vous sentir mieux.)

le type de comp2 demande deux fonctions, l'une de (a->b) et un autre (b->c), ainsi qu'un paramètre de type a. Il n'est pas nécessaire de mettre un a -> dans sa signature.

Les deux fonctions sont vraiment équivalentes; on utilise simplement des astuces Haskell pour être plus concis.

+0

merci, c'est clair maintenant. – 4DA

1

Currying. Une fonction multi-arguments dans ML et Haskell, est juste du sucre syntaxique pour une fonction à un argument qui retourne une fonction; la fonction qu'il renvoie prend les arguments restants.