चीज़ क्लब

फंक्शनल प्रोग्रामिंग क्या है?

हमारे उद्देश्य के लिए ये कुछ मुख्य विशेषताएँ हैं:

• प्योर फंक्शन, जो इनपुट को हमेशा एक ही तरीके से आउटपुट में बदलते हैं और उनका कोई साइड इफेक्ट नहीं होता।
• अपरिवर्तनीय डेटा।
• फर्स्ट-क्लास फंक्शन, जिन्हें किसी भी अन्य डेटा टाइप की तरह वैल्यू मानकर इस्तेमाल किया जा सकता है।
• हायर-ऑर्डर फंक्शन, जो दूसरे फंक्शन को आर्गुमेंट या रिटर्न वैल्यू के रूप में लेते हैं।

लेकिन R कोई शुद्ध फंक्शनल भाषा नहीं है (जैसे Haskell के विपरीत)।

R को एक व्यावहारिक भाषा मानिए, जो धीरे-धीरे ऐसी जगहों पर फंक्शनल क्षमताएँ देती जा रही है जहाँ ये काम पूरा करने का साफ और आसान तरीका हैं। आम तौर पर लक्ष्य डेटा विश्लेषण होता है, और प्रोग्रामिंग उस तक पहुँचने का बस एक साधन है।

पाइप

फंक्शनों को जोड़ने के लिए पाइप |> का इस्तेमाल कई भाषाओं में तेज़ी से आम होता जा रहा तरीका है।

संक्षेप में:

• पाइप के बाईं ओर का नतीजा दाईं ओर वाले फंक्शन का पहला आर्गुमेंट बन जाता है (यहाँ "दाईं ओर" कहते समय वैकल्पिक लाइन ब्रेक नहीं गिने जाते)।
• बचे हुए आर्गुमेंट फंक्शन कॉल में शामिल किए जा सकते हैं।
• R में हमें पाइप किसी फंक्शन कॉल तक करना होता है, सिर्फ नाम तक नहीं, इसलिए ब्रैकेट हमेशा लगाने पड़ते हैं (कुछ अन्य भाषाओं में ऐसा नहीं होता)।

कुछ प्रोग्रामर कोड देखते समय पाइप को "फिर" की तरह पढ़ना मददगार मानते हैं: पहले चरण 1 कीजिए, फिर चरण 2 कीजिए...

नीचे दिया गया उदाहरण इस सिंटैक्स को दिखाता है।

library(stringr)

"Monday-25-February" |> 
  str_split("-") |>     
  unlist() |>               # [1] "Monday"   "25"       "February"
  str_sub(1, 3) |>          # [1] "Mon" "25"  "Feb"
  str_to_upper() |>         # [1] "MON" "25"  "FEB"
  str_flatten(collapse = ", ")
#> [1] "MON, 25, FEB"

इस तरह का पाइप Base R में v4.1.0 में जोड़ा गया था, और इसे कहीं-कहीं "नेटिव पाइप" कहा जाता है।

RStudio एडिटर (और कई अन्य भी) उपयुक्त स्पेस के साथ पाइप जोड़ने के लिए Ctrl-Shift-M को कीबोर्ड शॉर्टकट की तरह इस्तेमाल करते हैं।

फंक्शन लगाना

हमने पहले देखा था कि R में बहुत से फंक्शन "वेक्टराइज़्ड" होते हैं: वे पूरे वेक्टर पर काम करते हैं, और उनके लिए अलग से लूप लिखने की ज़रूरत नहीं पड़ती।

जो फंक्शन सिर्फ वेक्टराइज़्ड फंक्शन इस्तेमाल करते हैं, वे भी अपने आप वेक्टराइज़्ड हो जाते हैं। एक छोटे उदाहरण में:

triple <- function(x) return(3 * x)
triple(1:10)
 [1]  3  6  9 12 15 18 21 24 27 30

लेकिन ज़्यादा जटिल फंक्शन वेक्टर इनपुट नहीं ले पाते, जैसे अगर उनमें लूप या if-else ब्लॉक हों।

हमें फंक्शनों को वेक्टर पर लगाने का एक ज़्यादा सामान्य तरीका चाहिए (कुछ अन्य भाषाओं के map() की तरह)।

चूँकि R की मूल भाषा में कई तरह की डेटा संरचनाएँ हैं, इसलिए उन पर काम करने के लिए *apply() फंक्शनों का एक पूरा परिवार भी है। तकनीकी रूप से इन्हें प्रोग्रामर अक्सर "हायर-ऑर्डर फंक्शन" कहते हैं और गणितज्ञ "फंक्शनल", क्योंकि ये फंक्शनों को आर्गुमेंट की तरह लेते हैं।

अभी के लिए lapply() और sapply() पर ध्यान दीजिए।

lapply()

"लिस्ट-अप्लाई" लिस्ट इनपुट पर काम करने के लिए बनाया गया है, लेकिन वेक्टर ज़रूरत पड़ने पर चुपचाप लिस्ट में बदल दिए जाते हैं।

आउटपुट एक लिस्ट होता है, इसलिए वेक्टर पाने के लिए इसे खोलना पड़ सकता है:

h <- function(size) {
    switch(size,
           "small" = 6,
           "medium" = 8,
           "large" = 10
    )
}

v <- c("small", "large", "medium")

h(v) # bad use of an unvectorized function
#> Error in switch(size, small = 6, medium = 8, large = 10) : 
#>   EXPR must be a length 1 vector

lapply(v, h)  # output is a list
#> [[1]]
#> [1] 6

#> [[2]]
#> [1] 10

#> [[3]]
#> [1] 8

lapply(v, h) |> unlist() # output is a vector
#> [1]  6 10  8

जो लोग Switch कॉन्सेप्ट जानते हैं, वे नोटिस कर सकते हैं कि हम स्केलर switch की जगह dplyr लाइब्रेरी के वेक्टराइज़्ड recode_values() का भी इस्तेमाल कर सकते हैं। वेक्टराइज़ेशन अच्छा है, और आधुनिक R इसे पाने के कई तरीके देती है।

library(dplyr)

h <- function(size) {
  recode_values(size,
         "small" ~ 6,
         "medium" ~ 8,
         "large" ~ 10
  )
}

v <- c("small", "large", "medium")
h(v)
#> [1]  6 10  8

sapply()

"सिंप्लिफाइड-अप्लाई" lapply जैसा ही काम करता है, लेकिन साथ ही रिटर्न वैल्यू को आसान बनाने की कोशिश करता है: जैसे लिस्ट की जगह नाम वाला वेक्टर। स्थिति के हिसाब से unname() का इस्तेमाल करना पड़ सकता है:

sapply(v, h)
 small  large medium 
     6     10      8 

sapply(v, h) |> unname()
#> [1]  6 10  8

purrr लाइब्रेरी

lapply और sapply सरल हैं, ज़्यादातर R उपयोगकर्ताओं के लिए परिचित हैं, और वेक्टर तथा साधारण लिस्ट के लिए आज भी काफी लोकप्रिय हैं।

Base R में कई दूसरे apply फंक्शन भी हैं। इस तरह की उलझन के लिए सरल और ज़्यादा एक जैसा विकल्प देना Tidyverse का एक मुख्य लक्ष्य है।

अब purrr पैकेज है, जो map() जैसे कई अतिरिक्त विकल्प देता है, और साथ ही डिज़ाइन में एकरूपता तथा एरर संदेशों की स्पष्टता भी बेहतर बनाता है।

Base R की तुलना में बैकवर्ड कंपैटिबिलिटी की बाधा कम होने के कारण, यह पैकेज R को अन्य भाषाओं में मिलती आधुनिक फंक्शनल प्रोग्रामिंग के काफी करीब ले आता है।

purrr में कई और अलग-अलग तरह के फंक्शन हैं, जिन्हें आसानी से सारांश में नहीं समेटा जा सकता। लाइब्रेरी को समझने में मदद करने वाले संसाधन:

• एक वेबसाइट, जिसमें शुरुआत करने की मार्गदर्शिका भी है।
• सभी फंक्शनों के लिए एक रेफरेंस पेज।
• PDF फॉर्मेट में एक चीट शीट।
• Base R से बदलने की मार्गदर्शिका।

कई तरह के map फंक्शन

map() फंक्शन इनपुट के हर एलिमेंट पर एक फंक्शन लगाता है, और हमेशा एक लिस्ट लौटाता है।

अब तक तो यह lapply() जैसा ही लगता है, बस नया नाम और शायद बेहतर एरर संदेशों के साथ।

लेकिन map() एक बड़े परिवार का बस एक सदस्य है।

फंक्शन चुनते समय सोचने के लिए कुछ सवाल:

• आप क्या लौटाना चाहते हैं? map() हमेशा लिस्ट लौटाता है, लेकिन अगर आप किसी खास तरह का एटॉमिक वेक्टर चाहते हैं तो स्ट्रिंग के लिए map_chr(), पूर्णांक के लिए map_int(), वगैरह इस्तेमाल कीजिए।
• क्या आपको इनपुट से हर स्थिति का इंडेक्स चाहिए? फंक्शन के नाम के आगे i लगाइए, जैसे imap()।
• क्या आप एक साथ कई इनपुट पर काम करना चाहते हैं?
  • नाम में map की जगह map2 लगाइए, जैसे दो इनपुट के लिए map2_dbl() (जैसे वैल्यू और वज़न, ताकि भारित औसत निकाला जा सके)
  • एक साथ कई इनपुट की लिस्ट के लिए pmap लगाइए, जैसे pmap_chr()। और हाँ, हार्डवेयर के स्तर पर समानांतरता भी संभव है।
• क्या आप इनपुट के सभी एलिमेंट पर काम करना चाहते हैं? अगर नहीं, तो सोचिए: प्रेडिकेट (बूलियन) फ़िल्टर लगाने के लिए map_if(), स्थिति के इंडेक्स की शर्तें तय करने के लिए map_at(), और इनपुट पर तब तक काम करने के लिए head_while() जब तक कोई एलिमेंट प्रेडिकेट पर खरा न उतरे।
• क्या इनपुट डेटा गहराई तक नेस्टेड है? उस स्थिति के लिए फंक्शन हैं।
• क्या आप चाहते हैं कि रिटर्न वैल्यू हमेशा इनपुट जैसे ही टाइप की हो? map की जगह modify() फंक्शन इस्तेमाल कीजिए, या बार-बार लगाने के लिए modify_tree()।

ये फंक्शन जहाँ भी संभव हो, इनपुट डेटा को पहला आर्गुमेंट बनाते हैं, ताकि वे पाइप के साथ ठीक से काम करें।

इसके अलावा, purrr (जानबूझकर) Base R से ज़्यादा सख्त है। अगर आप कुछ खास माँगते हैं, तो फंक्शन ठीक वही लौटाएँगे या एरर संदेश के साथ रुक जाएँगे। यह सख्ती है, लेकिन मुश्किल से मिलने वाले बग कम करने में बहुत असरदार है।

reduce फंक्शन

map फंक्शन आम तौर पर इनपुट जितनी ही लंबाई की रिटर्न वैल्यू देते हैं।

कुछ अन्य फंक्शन डेटा की आयाम-संख्या घटाते हैं, जैसे sum()।

sum(1:100)
#> [1] 5050

ऊपर के उदाहरण में हम 100 लंबाई के वेक्टर को 1 लंबाई के पूर्णांक में बदल देते हैं। मैट्रिक्स और ऐरे पर आने वाले किसी कॉन्सेप्ट में हम देखेंगे कि आयाम घटाने की धारणा इससे ज़्यादा सामान्य है।

sum() फंक्शन पहले से मौजूद है (और बहुत से दूसरे सांख्यिकीय फंक्शन भी)। लेकिन हमें किसी डेटा संरचना पर मनमाने आयाम घटाने वाले फंक्शन लगाने का तरीका चाहिए, map() के बराबर किसी हायर-ऑर्डर फंक्शन की मदद से।

कई अन्य भाषाओं में fold, foldl और foldr जैसे नाम इस्तेमाल होते हैं। R में इससे जुड़ा फंक्शन reduce() है, जो (एल्गोरिदम के शौकीनों में) मशहूर MapReduce फ्रेमवर्क से मेल खाता है।

पहला आर्गुमेंट, हमेशा की तरह, इनपुट डेटा है। दूसरा आर्गुमेंट दो आर्गुमेंट वाला फंक्शन है: अक्सर एक अनाम फंक्शन, लेकिन कभी-कभी + जैसा साधारण अंकगणितीय ऑपरेटर भी।

# surround an infix operator with backticks, to use as a function
reduce(1:100, `+`)
#> [1] 5050  # same as sum(1:100)

# anonymous function, alternately add and subtract
reduce(1:10, \(accum, nextval) ifelse(nextval %% 2 == 0, accum + nextval, accum - nextval))
#> [1] 7

क्या इससे कोई फर्क पड़ता है कि हम फंक्शन इनपुट की शुरुआत से लगाएँ या अंत से?

+ या * जैसे साहचर्य ऑपरेटरों के साथ नहीं। साफ है, (1 + 2) + 3 == 1 + (2 + 3)।

इसके उलट, - और / साहचर्य नहीं हैं:

(1 - 2) - 3
#> [1] -4
1 - (2 - 3)
#> [1] 2

जिन फंक्शनों में दिशा मायने रखती है, उनके लिए वैकल्पिक .dir आर्गुमेंट है।

# default is .dir = "forward"
reduce(1:10, `-`)
#> [1] -53
reduce(1:10, `-`, .dir = "backward")
#> [1] -5

map() और map2() की तरह, दो इनपुट वेक्टर पर एक साथ काम करने के लिए reduce2() फंक्शन भी है।

R में हमें वेक्टर के साथ काम करना पसंद है। मान लीजिए, आप एक आखिरी वैल्यू की जगह बीच के सारे चरण देखना चाहते हैं।

इसके लिए accumulate() और accumulate2() फंक्शन हैं। इनका सिंटैक्स reduce() जैसा है, बस आउटपुट टाइप बताने के लिए कुछ अतिरिक्त वैकल्पिक आर्गुमेंट होते हैं।

accumulate(1:10, `+`)
#> [1]  1  3  6 10 15 21 28 36 45 55

accumulate के कुछ आम प्रकारों के अपने फंक्शन हैं। Vector Functions कॉन्सेप्ट में Base R के cumsum() और cumprod() की बात हुई थी, और dplyr लाइब्रेरी में संख्यात्मक औसत के लिए cummean(), तथा लॉजिकल वेक्टर के लिए cumall() और cumany() हैं।

फ़िल्टर फंक्शन

अक्सर हम इनपुट के उन एलिमेंट को शामिल (या बाहर) करना चाहते हैं जो किसी प्रेडिकेट पर खरे उतरते हैं।

Vector Filtering कॉन्सेप्ट में हमने यह करने का एक खास तरीका देखा था।

v <- 1:3
v[v >= 2]
#> [1] 2 3

यह पुराने R में खूब इस्तेमाल होता है, लेकिन आधुनिक फंक्शनल पाइपलाइन में ठीक से नहीं बैठता।

इसीलिए purrr प्रेडिकेट फंक्शन का एक सेट देता है, जो पाइप के साथ काम करने के लिए आर्गुमेंट का आम तरीका f(input, func, ...) अपनाते हैं।

इनके नाम बाकी ज़्यादातर भाषाओं से थोड़े अलग हैं (filter और drop जैसे नामों का मतलब R में पहले से ही कुछ और है)।

इनसे जुड़े purrr फंक्शनों में keep() और discard(), तथा कई अन्य शामिल हैं।

साथ ही, एक ही लॉजिकल वैल्यू लौटाने में all() और any() की जगह लेने के लिए every(), some() और none() हैं।