Haskell Language
Composition de fonction
Recherche…
Remarques
L'opérateur de composition de fonctions (.) Est défini comme
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(.) f g x = f (g x) -- or, equivalently,
(.) f g = \x -> f (g x)
(.) f = \g -> \x -> f (g x)
(.) = \f -> \g -> \x -> f (g x)
(.) = \f -> (\g -> (\x -> f (g x) ) )
Le type (b -> c) -> (a -> b) -> (a -> c) peut être écrit comme (b -> c) -> (a -> b) -> a -> c car le -> dans les signatures de type "associates" à droite, correspondant à l'application associée à la gauche,
f g x y z ... == (((f g) x) y) z ...
Donc le "dataflow" est de droite à gauche: x "va" dans g , dont le résultat entre dans f , produisant le résultat final:
(.) f g x = r
where r = f (g x)
-- g :: a -> b
-- f :: b -> c
-- x :: a
-- r :: c
(.) f g = q
where q = \x -> f (g x)
-- g :: a -> b
-- f :: b -> c
-- q :: a -> c
....
Syntaxiquement, les éléments suivants sont identiques:
(.) f g x = (f . g) x = (f .) g x = (. g) f x
ce qui est facile à comprendre comme "les trois règles des sections de l' opérateur ", où "l'argument manquant" va juste dans l'emplacement vide près de l'opérateur:
(.) f g = (f . g) = (f .) g = (. g) f
-- 1 2 3
Le x , présent des deux côtés de l'équation, peut être omis. Ceci est connu comme eta-contraction. Ainsi, la manière la plus simple d’écrire la définition de la composition de fonction est juste
(f . g) x = f (g x)
Cela fait bien sûr référence à "l'argument" x ; chaque fois que nous écrivons simplement (f . g) sans le x il est appelé style sans point.
Composition de droite à gauche
(.) nous permet de composer deux fonctions, alimentant la sortie de l’une en entrée de l’autre:
(f . g) x = f (g x)
Par exemple, si nous voulons équarrir le successeur d’un nombre d’entrée, nous pouvons écrire
((^2) . succ) 1 -- 4
Il y a aussi (<<<) qui est un alias à (.) . Alors,
(+ 1) <<< sqrt $ 25 -- 6
Composition de gauche à droite
Control.Category définit (>>>) , qui, spécialisé dans les fonctions, est
-- (>>>) :: Category cat => cat a b -> cat b c -> cat a c
-- (>>>) :: (->) a b -> (->) b c -> (->) a c
-- (>>>) :: (a -> b) -> (b -> c) -> (a -> c)
( f >>> g ) x = g (f x)
Exemple:
sqrt >>> (+ 1) $ 25 -- 6.0
Composition avec fonction binaire
La composition régulière fonctionne pour des fonctions unaires. Dans le cas du binaire, on peut définir
(f .: g) x y = f (g x y) -- which is also
= f ((g x) y)
= (f . g x) y -- by definition of (.)
= (f .) (g x) y
= ((f .) . g) x y
Ainsi, (f .: g) = ((f .) . g) par eta-contraction, et de plus,
(.:) f g = ((f .) . g)
= (.) (f .) g
= (.) ((.) f) g
= ((.) . (.)) f g
so (.:) = ((.) . (.)) , une définition semi-célèbre.
Exemples:
(map (+1) .: filter) even [1..5] -- [3,5]
(length .: filter) even [1..5] -- 2
