Haskell Language
क्रिया रचना

समारोह रचना ऑपरेटर (.) के रूप में परिभाषित किया गया है

(.) :: (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) ) ) 

प्रकार (b -> c) -> (a -> b) -> (a -> c) रूप में लिखा जा सकता है (b -> c) -> (a -> b) -> a -> c क्योंकि -> दाईं ओर दिए गए फंक्शन एप्लिकेशन के अनुसार दाईं ओर स्थित हस्ताक्षर "सहयोगी" टाइप करें,

 f g x y z ...    ==    (((f g) x) y) z ...

तो "डेटाफ्लो" दाईं ओर से बाईं ओर है: x "जाता है" g , जिसका परिणाम f में जाता है, अंतिम परिणाम का उत्पादन:

(.)       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

....

कृत्रिम रूप से, निम्नलिखित सभी समान हैं:

(.) f g x  =  (f . g) x  =  (f .) g x  =  (. g) f x 

" ऑपरेटर सेक्शन के तीन नियम" के रूप में समझ पाना आसान है, जहां "लापता तर्क" बस ऑपरेटर के पास खाली स्लॉट में जाता है:

(.) f g    =  (f . g)    =  (f .) g    =  (. g) f   
--         1             2             3  

समीकरण के दोनों किनारों पर मौजूद x छोड़ा जा सकता है। इसे एटा-संकुचन के रूप में जाना जाता है। इस प्रकार, फ़ंक्शन रचना के लिए परिभाषा लिखने का सरल तरीका बस है

(f . g) x   =   f (g x)

यह पाठ्यक्रम "तर्क" x को संदर्भित करता है; जब भी हम x बिना सिर्फ (f . g) लिखते हैं तो इसे बिंदु मुक्त शैली के रूप में जाना जाता है।