Higher-order function: এটি কী, বৈশিষ্ট্য এবং Kotlin-এ উদাহরণ

Higher-order function কী?

Higher-order function হল একটি ফাংশন যার দুটি বৈশিষ্ট্যের মধ্যে কমপক্ষে একটি রয়েছে: অন্য ফাংশনকে আর্গুমেন্ট হিসেবে গ্রহণ করা বা ফলাফল হিসেবে ফাংশন রিটার্ন করা। গণিতে, এই ধরনের ফাংশনকে ফাংশনাল বা অপারেটর বলা হয়। প্রোগ্রামিং-এ, এগুলি 1958 সালে Lisp-এ আবির্ভূত হয় এবং সমস্ত আধুনিক ভাষার — JavaScript, Python, Swift, Kotlin, Scala এবং Haskell — একটি বাধ্যতামূলক অংশ হয়ে ওঠে। Higher-order function একটি নির্দিষ্ট অপারেশন থেকে বিমূর্ত হওয়ার এবং বিহেভিয়ারকে মান হিসেবে পাস করার অনুমতি দেয়।

Higher-order function এবং সাধারণ ফাংশনের মধ্যে মূল পার্থক্য হল একটি ফাংশনাল টাইপ সহ প্যারামিটার বা রিটার্ন করা ফাংশনাল মানের উপস্থিতি। Kotlin-এ, ফাংশনাল টাইপ (ParamType) -> ReturnType হিসেবে লেখা হয়। উদাহরণস্বরূপ, টাইপ (Int) -> String একটি ফাংশন বোঝায় যা Int নেয় এবং String রিটার্ন করে। টাইপ () -> Unit প্যারামিটারবিহীন একটি ফাংশন নির্দেশ করে যা কোনো কার্যকরী মান রিটার্ন করে না। এই টাইপ সিস্টেমই higher-order functions-কে টাইপ-নিরাপদ করে তোলে।

Higher-order function-এর বিপরীত হল first-class function (প্রথম শ্রেণীর ফাংশন)। First-class function মানে হল ফাংশনটি অন্য যেকোনো মানের মতো ব্যবহার করা যেতে পারে: ভেরিয়েবলে অ্যাসাইন করা, সংগ্রহে সংরক্ষণ করা, আর্গুমেন্ট হিসেবে পাস করা। Higher-order function হল একটি ফাংশন যা গ্রহণ বা রিটার্ন করার জন্য first-class functions ব্যবহার করে। Kotlin অতিরিক্ত লাইব্রেরি ছাড়াই ভাষা স্তরে উভয় ধারণাকে সমর্থন করে।

Kotlin-এ higher-order function কীভাবে কাজ করে?

Kotlin-এ, যেকোনো ফাংশন যার কমপক্ষে একটি প্যারামিটার ফাংশনাল টাইপের সাথে ঘোষিত বা যার রিটার্ন টাইপ ফাংশনাল, সেটি স্বয়ংক্রিয়ভাবে higher-order function হিসেবে বিবেচিত হয়। কম্পাইলারের কোনো বিশেষ অ্যানোটেশনের প্রয়োজন নেই — সিগনেচারে (T) -> R নির্দিষ্ট করাই যথেষ্ট। এই ধরনের ফাংশন কল করার সময়, আর্গুমেন্ট হয় একটি ল্যাম্বডা এক্সপ্রেশন, অথবা ::-এর মাধ্যমে বিদ্যমান ফাংশনের রেফারেন্স, অথবা ভেরিয়েবলে সংরক্ষিত একটি ফাংশনাল মান।

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum = operate(10, 20) { x, y -> x + y }
    println(sum) // 30
}

লিস্টিং-এ, operate ফাংশন দুটি পূর্ণসংখ্যা এবং টাইপ (Int, Int) -> Int-এর একটি op প্যারামিটার নেয়। ফাংশনের বডি এক লাইনে পাস করা অপারেশনটি কল করে। main-এ, operate-এর কল lambda { x, y -> x + y } পাস করে — Kotlin ট্রেলিং ল্যাম্বডা সিনট্যাক্সের কারণে এটি বন্ধনীর পরে রাখে। যদি ল্যাম্বডাটি শেষ আর্গুমেন্ট হত, তবে এটি সম্পূর্ণরূপে বন্ধনীর বাইরে সরানো যেত, যা কল চেইনের পঠনযোগ্যতা উন্নত করে।

অভ্যন্তরে, Kotlin Function ইন্টারফেসের মাধ্যমে higher-order functions কম্পাইল করে (দুই প্যারামিটারের জন্য Function2)। প্রতিটি ল্যাম্বডা একটি anonym ক্লাসে রূপান্তরিত হয় যা সংশ্লিষ্ট FunctionN ইন্টারফেস প্রয়োগ করে। এর মানে হল ল্যাম্বডা তৈরি করা প্রতিটি অপারেশনের জন্য অবজেক্ট বরাদ্দ করে। ওভারহেড কমানোর জন্য, Kotlin ইনলাইন ফাংশন সমর্থন করে, যা কল সাইটে higher-order function-এর বডি প্রতিস্থাপন করে, anonym ক্লাস তৈরি করা বাদ দেয়।

প্যারামিটার হিসেবে ফাংশন: বিহেভিয়ার পাসিং

একটি ফাংশনকে আর্গুমেন্ট হিসেবে পাস করা higher-order functions ব্যবহারের সবচেয়ে সাধারণ প্যাটার্ন। একটি পলিমরফিক মেথডের সাথে ক্লাস হায়ারার্কি তৈরি করার পরিবর্তে, ডেভেলপার কাঙ্ক্ষিত বিহেভিয়ার সরাসরি ব্যবহারের পয়েন্টে পাস করে। এটি ইনহেরিটেন্স ছাড়াই ওপেন/ক্লোজড নীতি প্রয়োগ করে: একটি নতুন অপারেশন নতুন সাবক্লাস হিসেবে নয়, বরং নতুন ল্যাম্বডা হিসেবে যুক্ত করা হয়।

নালযোগ্য ফাংশনের জন্য, Kotlin বন্ধনীর পরে প্রশ্নচিহ্ন সহ ((T) -> R)? টাইপ ব্যবহার করে। এই ধরনের ফাংশন শুধুমাত্র নাল-চেকের পরে বা ?.invoke() অপারেটরের মাধ্যমে কল করা যেতে পারে। এই ক্ষেত্রে, higher-order function-এর সিগনেচার স্পষ্টভাবে নির্দেশ করে যে ফাংশন পাস করা ঐচ্ছিক — কলিং কোড আর্গুমেন্টটি বাদ দিতে পারে। এটি ঐচ্ছিক বিহেভিয়ার সহ কলব্যাক এবং ইভেন্ট হ্যান্ডলারের জন্য দরকারী।

fun <T> List<T>.customFilter(
    predicate: (T) -> Boolean
): List<T> {
    val result = mutableListOf<T>()
    for (item in this) {
        if (predicate(item)) result.add(item)
    }
    return result
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val even = numbers.customFilter { it % 2 == 0 }
    println(even) // [2, 4]
}

এক্সটেনশন ফাংশন customFilter ফাংশনাল টাইপ (T) -> Boolean-এর একটি predicate প্যারামিটার নেয়। লুপের ভিতরে, এটি প্রতিটি উপাদানের জন্য predicate কল করে এবং ম্যাচ করা উপাদানগুলি সংগ্রহ করে। main-এ কল lambda { it % 2 == 0 } পাস করে, যেখানে it হল ল্যাম্বডার একমাত্র প্যারামিটারের অন্তর্নিহিত নাম। Higher-order functions-এর জন্য, ফিল্টারিং লজিক সংগ্রহ ট্রাভার্সাল মেকানিজম থেকে সম্পূর্ণ বিচ্ছিন্ন।

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

একটি higher-order function একটি ফাংশন রিটার্ন করতে পারে — এই প্যাটার্নটিকে ফাংশন ফ্যাক্টরি বা বিহেভিয়ার জেনারেটর বলা হয়। রিটার্ন করা ফাংশন বাইরের স্কোপ থেকে ভেরিয়েবল ক্যাপচার (ক্লোজার) করতে পারে, কলের মধ্যে সেগুলো সংরক্ষণ করে। এটি সাধারণ টেমপ্লেটের উপর ভিত্তি করে কনফিগারযোগ্য হ্যান্ডলার এবং বিশেষায়িত অপারেশন তৈরি করার অনুমতি দেয়।

একটি ফাংশন রিটার্ন করার সময়, Kotlin সিগনেচার থেকে রিটার্ন করা ফাংশনাল টাইপ ((T) -> R)? অনুমান করে। কম্পাইলার চেক করে যে বডির সমস্ত return এক্সপ্রেশন সামঞ্জস্যপূর্ণ ফাংশনাল মান রিটার্ন করে। ক্যাপচার করা ভেরিয়েবলগুলি ল্যাম্বডা অবজেক্টে সংরক্ষিত হয় এবং যতক্ষণ পর্যন্ত এটির রেফারেন্স বিদ্যমান থাকে ততক্ষণ অ্যাক্সেসযোগ্য থাকে। এটি একটি শক্তিশালী প্রক্রিয়া, তবে মেমরি ব্যবস্থাপনার প্রতি মনোযোগ প্রয়োজন।

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { x -> x * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)
    println(double(5))  // 10
    println(triple(5)) // 15
}

makeMultiplier ফাংশন একটি ফ্যাক্টর নেয় এবং lambda { x -> x * factor } রিটার্ন করে, যেখানে factor বাইরের স্কোপ (ক্লোজার) থেকে ক্যাপচার করা হয়েছে। makeMultiplier-এর প্রতিটি কল তার নিজস্ব ফ্যাক্টর মান সহ একটি নতুন ফাংশন তৈরি করে। double এবং triple ভেরিয়েবল রিটার্ন করা ফাংশনগুলি সংরক্ষণ করে এবং একাধিকবার কল করা যেতে পারে। এই প্যাটার্নটি HTTP ক্লায়েন্ট কনফিগারেশন, ডেকোরেটর এবং মিডলওয়্যারে ব্যাপকভাবে ব্যবহৃত হয়।

ল্যাম্বডার সাথে higher-order function: উদাহরণ

Higher-order functions এবং ল্যাম্বডার সম্মিলিত ব্যবহার ইন্টারমিডিয়েট ভেরিয়েবল ছাড়াই এক্সপ্রেসিভ অপারেশন চেইন তৈরি করার অনুমতি দেয়। Kotlin স্ট্যান্ডার্ড লাইব্রেরিতে ডজনখানেক higher-order functions রয়েছে: let, run, apply, also, filter, map, flatMap, fold, reduce, forEach, groupBy এবং অন্যান্য। প্রতিটি একটি ল্যাম্বডা নেয় এবং এর সাথে ডেটা ট্রান্সফরমেশন করে।

data class User(val name: String, val age: Int)

fun main() {
    val users = listOf(
        User("Alice", 25),
        User("Bob", 17),
        User("Charlie", 30)
    )

    val result = users
        .filter { it.age >= 18 }
        .map { it.name.uppercase() }
        .sorted()
    println(result) // [ALICE, CHARLIE]
}

উদাহরণে, তিনটি higher-order functions-এর একটি চেইন ব্যবহারকারীদের একটি তালিকা প্রক্রিয়া করে। filter একটি প্রেডিকেট নেয়, শুধুমাত্র প্রাপ্তবয়স্কদের রেখে দেয়। map প্রতিটি ব্যবহারকারীকে বড় হাতের অক্ষরে নামে রূপান্তর করে। sorted ফলাফলকে ঊর্ধ্বক্রমে সাজায়। প্রতিটি অপারেশন একটি ল্যাম্বডা নেয়, এবং Kotlin প্রতিটি ধাপে টাইপ নিরাপত্তা নিশ্চিত করে। Higher-order functions ছাড়া, if-সহ লুপ, অস্থায়ী তালিকা এবং ম্যানুয়াল সর্টিং লিখতে হত।