पॉइंटफ्री शैली में लिखना f x = g x x

Question

मैं हास्केल सीख रहा हूं। मुझे एक बहुत ही बुनियादी सवाल पूछने के लिए खेद है, लेकिन मुझे जवाब नहीं मिल रहा है। मेरे पास एक फंक्शन एफ है:

f x = g x x 

जहां जी 2 तर्कों का पहले से परिभाषित कार्य है। मैं इस पॉइंटफ्री शैली को कैसे लिखूं? संपादित करें: एक लैम्ब्डा अभिव्यक्ति का उपयोग किए बिना।

धन्यवाद

Answer 1

fControl.Monad.join साथ लिखा जा सकता है:

f = join g 

समारोह इकाई पर join जब, बिंदु से मुक्त भाव निर्माण के रूप में यह एक बिंदु में परिभाषित नहीं किया जा सकता है इस्तेमाल किया पुरातन में से एक है मुक्त शैली (इसके SKI calculus समकक्ष, SII - ap id id हास्केल में - टाइप नहीं करता है)।

Answer 2

यह "W" combinator के रूप में जाना जाता है:

import Control.Monad 
import Control.Monad.Instances 
import Control.Applicative 

f = join g  -- = Wg  (also, join = (id =<<)) 
    = (g `ap` id) -- \x -> g x (id x) = SgI 
    = (<*> id) g --     = CSIg 
    = g =<< id  -- \x -> g (id x) x 
    = id =<< g  -- \x -> id (g x) x 

S,K,I combinators में से एक बुनियादी सेट कर रहे हैं; B,C,K,W एक और कर रहे हैं - आप को रोकने के लिए मिल गया है कहीं^{(पुन: अपने "कोई लैम्ब्डा अभिव्यक्ति" टिप्पणी)}:

_B = (.)  -- _B f g x = f (g x)  = S(KS)K 
_C = flip -- _C f x y = f y x  = S(S(K(S(KS)K))S)(KK) 
_K = const -- _K x y = x 
_W = join -- _W f x = f x x  = CSI = SS(KI) = SS(SK) 
_S = ap  -- _S f g x = f x (g x) = B(B(BW)C)(BB) = B(BW)(BBC) 
    = (<*>)        -- from Control.Applicative 
_I = id  -- _I x  = x   = WK = SKK = SKS = SK(...) 

{- 
Wgx = gxx 
    = SgIx = CSIgx 
      = Sg(KIg)x = SS(KI)gx 
    = gx(Kx(gx)) = gx(SKgx) = Sg(SKg)x = SS(SK)gx 

-- _W (,) 5 = (5,5) 
-- _S _I _I x = x x = _omega x   -- self-application, untypeable 
-}