চিজ ক্লাব

ফাংশনাল প্রোগ্রামিং কী?

আমাদের আলোচনার প্রেক্ষিতে, এর কয়েকটি মূল বৈশিষ্ট্য হলো:

• পিউর ফাংশন, যেগুলো ইনপুটকে ধারাবাহিকভাবে আউটপুটে ম্যাপ করে এবং যেগুলোর কোনো সাইড ইফেক্ট থাকে না।
• ইমিউটেবল ডেটা।
• ফার্স্ট-ক্লাস ফাংশন, যেগুলো অন্য যেকোনো ডেটা টাইপের মতো মান হিসেবেও ব্যবহার করা যায়।
• হায়ার-অর্ডার ফাংশন, যেগুলো অন্য ফাংশনকে আর্গুমেন্ট হিসেবে বা রিটার্ন ভ্যালু হিসেবে নেয়।

তবে R কোনো পিউর ফাংশনাল ভাষা নয় (যেমন Haskell-এর বিপরীতে)।

R-কে একটি প্র্যাকম্যাটিক ভাষা হিসেবে দেখুন, যা (ক্রমশ বাড়তে থাকা হারে) ফাংশনাল সামর্থ্য দেয় সেখানে, যেখানে এগুলো কাজ সম্পন্ন করার একটি পরিচ্ছন্ন ও সহজ উপায়। সাধারণভাবে ডেটা বিশ্লেষণই লক্ষ্য, আর প্রোগ্রামিং শুধু সেই লক্ষ্যে পৌঁছানোর একটি উপায়।

পাইপ

কয়েকটি ভাষায় ফাংশনগুলোকে সংযুক্ত করতে |> পাইপ ব্যবহার করা ক্রমশ কমন একটি কৌশল।

সংক্ষেপে:

• পাইপের বাম দিকের একটি ফলাফল ডান দিকের ফাংশনের প্রথম আর্গুমেন্ট হয়ে যায় (এখানে "ডান" বলতে ঐচ্ছিক লাইন ব্রেক উপেক্ষা করা হয়)।
• বাকি যেকোনো আর্গুমেন্ট ফাংশন কলে যোগ করা যায়।
• R-এ আমাদের পাইপ করতে হয় একটি ফাংশন কল-এর কাছে, শুধু একটি নাম-এর কাছে নয়, তাই বন্ধনী সবসময় আবশ্যক (এটি অন্য কিছু ভাষার থেকে আলাদা)।

কোড পর্যালোচনা করার সময় কিছু প্রোগ্রামার পাইপটিকে "then" হিসেবে উচ্চারণ করা সহায়ক মনে করেন: প্রথম ধাপ করুন THEN দ্বিতীয় ধাপ করুন...

নিচের উদাহরণটি সিনট্যাক্সটি দেখায়।

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()-এর মতো)।

যেহেতু Base R-এর ভাষায় নানা রকমের ডেটা স্ট্রাকচার আছে, তাই সেগুলোতে কাজ করার জন্য *apply() ফাংশনের একটি পুরো পরিবারও আছে। আরও কারিগরি ভাষায়, প্রোগ্রামাররা এগুলোকে প্রায়ই "হায়ার-অর্ডার ফাংশন" বলেন আর গণিতবিদরা বলেন "ফাংশনাল", কারণ এগুলো ফাংশনকে আর্গুমেন্ট হিসেবে নেয়।

আপাতত lapply() ও sapply() নিয়ে ভাবুন।

lapply()

"List-apply" অ্যারে ইনপুটে কাজ করার জন্য তৈরি, তবে প্রয়োজন হলে ভেক্টরগুলোকে নীরবে অ্যারেতে রূপান্তর করা হয়।

আউটপুট একটি অ্যারে, তাই ভেক্টর পেতে এটিকে আনপ্যাক করতে হতে পারে:

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

"Simplified-apply" 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-এ আরও অনেক অ্যাপ্লাই ফাংশন আছে। এই ধরনের বিভ্রান্তির জন্য আরও সহজ ও বেশি সামঞ্জস্যপূর্ণ একটি বিকল্প দেওয়া Tidyverse-এর একটি মূল লক্ষ্য।

এখন purrr প্যাকেজটি আছে, যা map()-এর মতো আরও কয়েকটি অপশন দেয়, একইসাথে ডিজাইনে সামঞ্জস্য আর এরর মেসেজে স্পষ্টতা বাড়ায়।

Base R-এর তুলনায় ব্যাকওয়ার্ড কম্প্যাটিবিলিটির বাধা কম থাকায়, এই প্যাকেজ R-কে অন্য ভাষায় দেখা আধুনিক ফাংশনাল প্রোগ্রামিংয়ের অনেক কাছাকাছি নিয়ে আসে।

purrr-এ বহু ও বিচিত্র ফাংশন আছে, যেগুলো সহজে সারসংক্ষেপ করা যায় না। লাইব্রেরিটি ঘুরে দেখতে সহায়ক কিছু রিসোর্স:

• একটি ওয়েবসাইট, যার মধ্যে রয়েছে একটি শুরু করার গাইড।
• সব ফাংশনের জন্য একটি রেফারেন্স পেজ।
• PDF ফরম্যাটে একটি চিট শিট।
• Base R থেকে রূপান্তরের একটি গাইড।

নানা রকম ম্যাপ ফাংশন

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-এর চেয়ে বেশি খুঁতখুঁতে। আপনি যদি নির্দিষ্ট কিছু চান, ফাংশনগুলো ঠিক সেটাই রিটার্ন করবে, নাহলে একটি এরর মেসেজ দিয়ে থেমে যাবে। কঠিন, কিন্তু খুঁজে পাওয়া কষ্টকর বাগ কমাতে খুবই কার্যকর।

রিডিউস ফাংশন

ম্যাপ ফাংশনগুলোর রিটার্ন ভ্যালু সাধারণত ইনপুটের সমান দৈর্ঘ্যের হয়।

কিছু অন্য ফাংশন ডেটার ডাইমেনশনালিটি কমিয়ে আনে, যেমন sum()।

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

উপরের ক্ষেত্রে আমরা ১০০ দৈর্ঘ্যের একটি ভেক্টরকে ১ দৈর্ঘ্যের একটি ইন্টিজারে রূপান্তর করি। ম্যাট্রিক্স ও অ্যারে নিয়ে ভবিষ্যতের একটি কনসেপ্টে দেখব, ডাইমেনশন কমানোর ধারণাটি আরও সাধারণ।

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

কিছু কমন অ্যাকিউমুলেট টাইপের নিজস্ব ফাংশন আছে। 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, ...)-এর প্রচলিত আর্গুমেন্ট রীতিটি অনুসরণ করে।

নামগুলো বেশিরভাগ অন্য ভাষার থেকে একটু আলাদা (R-এ filter আর drop-এর মতো নামের অর্থ আগে থেকেই সম্পূর্ণ ভিন্ন কিছু)।

সংশ্লিষ্ট purrr ফাংশনগুলোর মধ্যে আছে keep() ও discard(), আরও কয়েকটি সহ।

এছাড়া একটি একক লজিক্যাল মান রিটার্ন করার ক্ষেত্রে all() ও any()-এর বদলে আমাদের আছে every(), some() ও none()।