जावास्क्रिप्ट

Question

में के-संयोजक (केस्ट्रल) का व्यावहारिक उपयोग नीचे के रूप में के-संयोजक को कार्यान्वित किया जा सकता है और कार्यान्वयन का कोई दुष्प्रभाव नहीं होना चाहिए।

const K = x => y => x; 

इसे कभी-कभी "कॉन्स्ट" (हास्केल में) कहा जाता है। के फ़ंक्शन को परिभाषित किया जा सकता है, "एक मान लेता है और एक (स्थिर) यूनरी फ़ंक्शन देता है जो हमेशा उस मान को देता है।"

यह कब उपयोगी है? व्यावहारिक उदाहरणों के साथ कृपया मेरी मदद करें।

Answer 1

K के साथ समस्या सभी आदिम संयोजकों के साथ यह है कि आप इसे अपने आप नहीं मान सकते हैं। आदिम संयोजक कार्यात्मक प्रोग्रामिंग के मौलिक बिल्डिंग ब्लॉक हैं। उन्हें काम पर देखने के लिए आपको एक उचित संदर्भ की आवश्यकता है। चुनौती इस संदर्भ को ग्रोक करना है, यदि आप कार्यात्मक प्रतिमान के लिए नए हैं।

यहां एक "सामान्य संदर्भ" है: Option।

// the option type 
 

 
const Option = { 
 
    some: Symbol.for("ftor/Option.some"), 
 

 
    none: Symbol.for("ftor/Option.none"), 
 

 
    of: x => factory(Option.some) (x), 
 

 
    cata: pattern => o => pattern[o.tag](o.x), 
 

 
    fold: f => g => o => Option.cata({[Option.some]: f, [Option.none]: g}) (o), 
 

 
    map: f => o => Option.fold(x => Option.of(f(x))) (K(o)) (o) 
 
    //            ^^^^ 
 
} 
 

 

 
// a generic map function 
 

 
const map = type => f => o => type.map(f) (o); 
 

 

 
// functor factory 
 

 
const factory = tag => value => (
 
    {x: value === undefined ? null : value, tag: tag} 
 
); 
 

 

 
// auxiliary functions 
 

 
const K = x => y => x; 
 
const sqr = x => x * x; 
 

 

 
// a few data to play around 
 

 
const o = factory(Option.some) (5); 
 
const p = factory(Option.none)(); 
 

 

 

 
// and run 
 

 
let r1 = map(Option) (sqr) (o); 
 
let r2 = map(Option) (sqr) (p); 
 

 
console.log("map over o", r1); 
 
console.log("map over p", r2);

K इस कार्यान्वयन में क्या करता है: Option प्रकार के उदाहरण है जब एक समारोह के लिए आवेदन किया मूल्यों null हो सकता है कि की तरह हैं, लेकिन कभी नहीं एक त्रुटि फेंक? के महत्वपूर्ण लाइन जांच:

f => o => Option.fold(x => Option.of(f(x))) (K(o)) (o) 

Option.fold दो कार्यों की उम्मीद है। पहला पारित कार्य x => Option.of(f(x))some केस के लिए है (एक मान है)। none मामले के लिए दूसरा K(o) (कोई मूल्य नहीं है)। आइए याद रखें कि K दो तर्क K = x => y => {return x} की अपेक्षा करता है। K(o)o से x असाइन करता है। कोई फर्क नहीं पड़ता कि दूसरे तर्क के रूप में क्या पारित किया गया है, K हमेशा y को अनदेखा कर देगा और इसके बजाय x लौटाएगा।

लेकिन oK(o) अभिव्यक्ति में प्रतिनिधित्व करता है? यह Option.none का प्रतिनिधित्व करता है जो कि मूल्य की अनुपस्थिति है। तो जब कोई fnone पर 0xपर नक्शा मैप करने का प्रयास करता है, तो fK पर दूसरे तर्क के रूप में गुजरता है, इससे कोई फर्क नहीं पड़ता।

Answer 2

के संयोजक को चर्च-एन्कोडेड बूलियन का उपयोग करते समय भी सत्य-मूल्य के रूप में उपयोग किया जा सकता है। आईई। अगर टेस्ट ईएलएसई: यदि आपका "आईएफ-टेस्ट" के रिटर्न देता है, तो "अन्य" गिरा दिया जाएगा और "फिर" निष्पादित किया जाएगा।

Answer 3

एक व्यापक प्रश्न का क्रमबद्ध करें, लेकिन यह अच्छा है, मुझे यह पसंद है।

मेरे उदाहरण का समर्थन करने के लिए, इस उत्तर में मैं लागू करने जा रहा हूं और नरकिप;

abuild :: Number -> (Number -> a) -> [a] 

और नरकिप; जैसा कि प्रकार बताता है, एक सरणी बनाने के लिए एक संख्या और एक समारोह लेता है। यह उपयोगी हो सकता है यदि आप कुछ गणना के आधार पर किसी ज्ञात आकार की सरणी बनाना चाहते हैं।

---

की पहचान समारोह, id का उपयोग कर 5 तत्वों के साथ एक सरणी का निर्माण करते हैं।आप देख सकते हैं, एक अनुक्रमिक संख्यात्मक 0 से आरंभ सूचकांक समारोह अपने बिल्डर को दिया जाता है

abuild (5) (आईडी) // => [0,1,2,3,4]

चलो इस बार बिल्डर के साथ कुछ मैथी करें। हम इनपुट स्क्वायर करेंगे। बहुत उन्नत

abuild (5) (x=> x * x) 
// => [0,1,4,9,16] 

या शायद हमें इनपुट की परवाह नहीं है। मैं हमेशा एक अच्छा हंसी प्यार करता हूँ। मैं लगातार चीजों पर हँसता हूं। कोई कह सकता है कि मैं K('ha') और नरक;

abuild (5) (K('ha')) 
// => ['ha','ha','ha','ha','ha'] 

बूम! बहुत उपयोगी, है ना? यही कारण है कि K

---

कार्यान्वयन

आगे बढ़ो और कार्रवाई में K देखने के लिए इसे चलाने है!

// id :: a -> a 
 
const id = x=> x 
 

 
// K :: a -> b -> a 
 
const K = x=> y=> x 
 

 
// add :: Number -> Number -> Number 
 
const add = x=> y=> y + x 
 

 
// reduce :: (a -> b) -> b -> [a] -> b 
 
const reduce = f=> y=> ([x,...xs])=> { 
 
    if (x === undefined) 
 
    return y 
 
    else 
 
    return reduce (f) (f (y) (x)) (xs) 
 
} 
 

 
// map :: (a -> b) -> [a] -> [b] 
 
const map = f=> reduce (xs=> x=> [...xs, f(x)]) ([]) 
 

 
// iterate :: Number -> (a -> a) -> a -> [a] 
 
const iterate = n=> f=> x=> 
 
    n > 0 ? [x, ...iterate (n - 1) (f) (f(x))] : [] 
 

 
// abuild :: Number -> (Number -> a) -> [a] 
 
const abuild = n=> f=> 
 
    map (f) (iterate (n) (add (1)) (0)) 
 

 
console.log(abuild (5) (id)) 
 
// => [0,1,2,3,4] 
 

 
console.log(abuild (5) (x=> x * x)) 
 
// => [0,1,4,9,16] 
 

 
console.log(abuild (5) (K('ha'))) 
 
// => ['ha','ha','ha','ha','ha']