স্থানাঙ্ক রূপান্তর

ফাংশনের সঙ্গে পরিচয় হয়েছিল আগেই বেসিকস কনসেপ্টে, এ রকম কিছু উদাহরণ দিয়ে:

squareit <- function(x) {
    x * x
}

squareit(3)
#> [1] 9

# shorter form
squareit_short <- function(x) x ^ 2

squareit-এর ডেফিনিশনটি একটু ভালো করে দেখলে আমরা কয়েকটি আলাদা অংশ চিনতে পারি:

• ফাংশনটি একটি ফর্মাল আর্গুমেন্ট x নেয়।
• একটি ফাংশন বডি থাকে, সাধারণত ব্রেস{ }-এর ভেতরে।
• ফাংশন অবজেক্টটি তৈরি হয়ে গেলে সেটি squareit নামের একটি ভ্যারিয়েবলে অ্যাসাইন করা হয়।

R-এ একটি ফাংশন ফার্স্ট ক্লাস অবজেক্ট, অনেকটা সংখ্যা আর স্ট্রিংয়ের মতো। তাই squareit <- function... হলো একটি অ্যাসাইনমেন্ট, যা সিনট্যাক্সের দিক থেকে x <- 42-এর মতোই।

আর্গুমেন্ট

Python আর Julia-র মতো অন্য স্ক্রিপ্টিং ভাষার বিপরীতে R পজিশনাল আর্গুমেন্ট আর কিওয়ার্ড আর্গুমেন্টের মধ্যে স্পষ্ট কোনো পার্থক্য করে না।

ফাংশন কল করার সময় মান পাস করা যায় পজিশন ধরে, আবার নাম ধরে। পরের পদ্ধতিটি অনেক আর্গুমেন্টওয়ালা জটিল ফাংশনের ক্ষেত্রে কাজে লাগে, যেখানে আর্গুমেন্টের ক্রম মনে রাখা কঠিন।

f <- function(x, y) x / y

# call positionally
f(4, 2)
#> [1] 2

# call by name
f(y = 2, x = 4)
#> [1] 2

ঐচ্ছিক আর্গুমেন্ট

ফাংশনের ডেফিনিশনে ডিফল্ট আর্গুমেন্ট মান উল্লেখ করা যায়, তবে সেগুলো ডিফল্টহীন সব আর্গুমেন্টের পরে থাকতে হবে।

এরপর ডিফল্টটি মেনে নেব, নাকি সেটি ওভাররাইড করব, তা আমরা বেছে নিতে পারি।

g <- function(x, y = 2) x / y

# default y value
g(6)
#> [1] 3

# explicit y value
g(6, 3)
#> [1] 2

অতিরিক্ত আর্গুমেন্ট

ইচ্ছেমতো সংখ্যক অতিরিক্ত আর্গুমেন্ট নিতে হলে ডেফিনিশনে একটি ... (ইলিপসিস) ব্যবহার করুন। ফাংশন কলে দেওয়া অতিরিক্ত যেকোনো মানকে একটি ভেক্টরে রূপান্তর করা সম্ভব, তবে এই "ডট আর্গস" (অন্য অনেক ভাষায় "varargs" নামে পরিচিত) ব্যবহারের আরেকটি উপায় জানতে সামনে পড়ুন।

var_f <- function(x, y, ...) {
  print(c(...))
}

var_f(2, 3, "opt1", "opt2")
#> [1] "opt1" "opt2"

ফাংশনের এনভায়রনমেন্ট

আগে আমরা বলেছি, ফর্মাল আর্গুমেন্ট আর বডি, দুটোই একটি ফাংশনের উপাদান।

আসলে আরেকটি তৃতীয় উপাদানও আছে: যে এনভায়রনমেন্টে ফাংশনটি ডিফাইন করা হয়।

নেস্টেড ফাংশনের উদাহরণ দিয়ে এটি বোঝা যায়:

outer_func <- function(x) {
  inner_func <- function(y) {
    x * y
  }
  
  inner_func(3)
}

outer_func(5)
#> [1] 15

ফাংশন কলটি বাইরের ফাংশনে x = 5 পাস করে, আর এই মানটি ওই ফাংশন বডির ভেতরে পাওয়া যায়।

ভেতরের ফাংশনটি বাইরের ফাংশন বডিরই একটি অংশ, আর এর কাছে x-এর মানে প্রবেশাধিকার আছে। অন্যভাবে বললে, x = 5 ভেতরের ফাংশনের এনভায়রনমেন্টে আছে।

প্রযুক্তিগতভাবে এটিকে বলা হয় ক্লোজার।

ডট আর্গসের ক্ষেত্রে এনভায়রনমেন্ট বিশেষভাবে গুরুত্বপূর্ণ, কারণ এভাবে দেওয়া যেকোনো মান ফাংশন বডির ভেতরের ফাংশন কলে পাস করা যায়। ডট আর্গসগুলোর অর্থ কী, তা বাইরের ফাংশনকে জানতে বা ভাবতে হয় না।

f_var <- function(x, ...) {
  sum(x, ...)
}

x <- c(1, 2, NA, 6)

# for sum(), na.rm defaults to FALSE
f_var(x)
#> [1] NA

# pass through the na.rm value
f_var(x, na.rm = TRUE)
#> [1] 9

Tidyverse-এর stringr-এর মতো লাইব্রেরিগুলো এই কৌশলটি ব্যাপকভাবে ব্যবহার করে। stringr-এর অনেক ফাংশনই stringi আর বেস R-এর লো-লেভেল ফাংশনের ওপর একটি ব্যবহারবান্ধব র্যাপার।

str_*() ফাংশনে দেওয়া অতিরিক্ত আর্গুমেন্টগুলো সোজা ওই নিচু স্তরের ফাংশনগুলোতে পাস হয়ে যায়।

রিটার্ন ভ্যালু হিসেবে ফাংশন

একটি বাইরের ফাংশন ভেতরে আরেকটি ফাংশন ডিফাইন করতে পারে (নামযুক্ত, বা নিচে বর্ণিত অ্যানোনিমাস) এবং সেটিকে রিটার্ন ভ্যালু হিসেবে ব্যবহার করতে পারে।

যে ফাংশনটি রিটার্ন হয়, তার সঙ্গে যে এনভায়রনমেন্টে এটি ডিফাইন করা হয়েছিল, সেটিও থাকে।

times_y <- function(x) {
  # anonymous function - see next section
  \(y) x * y
}

f <- times_y(3)
class(f)
#> [1] "function"

f(4)
#> [1] 12

অ্যানোনিমাস ফাংশন

কোনো ফাংশন ডিফাইন করার সময় আমরা সাধারণত তৈরি হওয়া ফাংশন অবজেক্টটি একটি ভ্যারিয়েবলের সঙ্গে বেঁধে দিই।

x <- 2

# function definition captures x from the environment
doubleit_short <- function(y) x * y

এতে স্ক্রিপ্টের পরে আবার ফাংশনটি ব্যবহার করা সহজ হয়, তবে এমন বাঁধন সব সময় দরকার নেই। ছোট, একবারই ব্যবহারের ফাংশন কাছের কাজে কাজে লাগতে পারে। নামের সঙ্গে না বাঁধলে এটিকে বলা হয় অ্যানোনিমাস ফাংশন।

অ্যানোনিমাস ফাংশনের ব্যবহার এতটাই সাধারণ যে (R v4.1.0 থেকে) এগুলো ডিফাইন করার একটি সংক্ষিপ্ত সিনট্যাক্স আছে: function শব্দটির বদলে একটি ব্যাকস্ল্যাশ \ লিখুন।

এর একটি উদাহরণ আগের অংশে, রিটার্ন ভ্যালু নিয়ে আলোচনায় ব্যবহার করা হয়েছে।

কপি অন মডিফাই

R একটি ভেক্টরের আলাদা আলাদা এলিমেন্টে অ্যাসাইনমেন্ট করতে দেয়। যদি আমরা একটি ভেক্টর ফাংশনের আর্গুমেন্ট হিসেবে পাস করি, আর রিটার্ন করার আগে ফাংশন বডিতে সেটি পরিবর্তন করি, তাহলে আমরা একটি পরিবর্তিত ভেক্টর পাই।

কিন্তু মূল ভেক্টরটির কী হলো?

f <- function(vec) {
  vec[1] <- 42
  vec
}

vals <- c(1, 3, 4)

# f() returns a modified vector
f(vals)
#> [1] 42  3  4  

# the original vector is unchanged.
vals
#> [1] 1 3 4

R হলো ডেটা সায়েন্সের জন্য তৈরি একটি ভাষা। সেই ডেটা সংগ্রহ করতে সময়, পরিশ্রম, আর সম্ভবত চোখ কপালে ওঠানোর মতো পরিমাণ অর্থ খরচ হতে পারে: তাই এটি নষ্ট না করা জরুরি!

সাধারণ নীতি (কয়েকটি ব্যতিক্রম বাদে) হলো কপি অন মডিফাই। যদি কোনো অবজেক্ট (যেমন একটি ভেক্টর) এমনভাবে পরিবর্তিত হয় যা পরে সমস্যা ডেকে আনতে পারে, তাহলে R একটি পরিবর্তিত কপি ফেরত দেয় আর মূলটি অপরিবর্তিত রেখে দেয়।

বড় ডেটা স্ট্রাকচার কপি করা কম্পিউটেশনের দিক থেকে ব্যয়বহুল হতে পারে, কিন্তু বিকল্পটি যখন ডেটা নষ্ট হয়ে যাওয়া, তখন সাধারণত এটিই কম ক্ষতিকর।