Lambda: এটি কী, সিনট্যাক্স এবং Kotlin-এ ব্যবহার

Lambda কী?

Lambda (lambda এক্সপ্রেশন) হল একটি অজ্ঞাতনামা ফাংশন যা একটি ঘোষণার পরিবর্তে একটি এক্সপ্রেশন হিসাবে সংজ্ঞায়িত হয়। শব্দটি অ্যালোনজো চার্চের lambda ক্যালকুলাস (1936) থেকে উদ্ভূত হয়েছে। প্রোগ্রামিং-এ, lambda হল কোডের একটি ব্লক যা মান হিসাবে পাস করা, একটি ভেরিয়েবলে সংরক্ষণ করা এবং পরে কল করা যায়। Kotlin-এ, lambda সর্বদা কোঁকড়া বন্ধনী { }-এর মধ্যে আবদ্ধ থাকে, আর্গুমেন্টগুলি -> তীর দ্বারা বডি থেকে পৃথক করা হয়।

Lambda একটি সাধারণ ফাংশন থেকে নাম এবং fun কীওয়ার্ডের অনুপস্থিতিতে ভিন্ন। এটি অতিরিক্ত ঘোষণা ছাড়াই ব্যবহারের বিন্দুতে সরাসরি আচরণ ঘোষণা করতে দেয়। Kotlin কম্পাইলার প্রসঙ্গ থেকে আর্গুমেন্টের প্রকার অনুমান করে, তাই অনেক ক্ষেত্রে প্রকার বাদ দেওয়া যায়। Lambda কার্যকরী প্রকার (T) -> R-এর উপর সিনট্যাক্টিক সুগার: প্রতিটি lambda-এর একটি সংশ্লিষ্ট কার্যকরী প্রকার রয়েছে।

Kotlin-এ lambdas-এর প্রাথমিক ব্যবহার হল সেগুলিকে উচ্চ-ক্রম ফাংশনে পাস করা। স্ট্যান্ডার্ড লাইব্রেরি সর্বত্র lambdas ব্যবহার করে: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambdas ইভেন্ট লিসেনার, কলব্যাক এবং apply ও run-এর মাধ্যমে অবজেক্ট কনফিগারেটরের জন্যও ব্যবহৃত হয়, যা অজ্ঞাতনামা ক্লাসের তুলনায় কোডকে আরও ঘোষণামূলক করে তোলে।

Kotlin-এ lambda এক্সপ্রেশনের সিনট্যাক্স

Kotlin-এ lambda এক্সপ্রেশন-এর পূর্ণ রূপ: { আর্গুমেন্টস -> lambda_বডি }. আর্গুমেন্টগুলি কমা দ্বারা পৃথক করে তালিকাভুক্ত করা হয়, তারপরে একটি তীর এবং বডি — এক বা একাধিক এক্সপ্রেশন। যদি বডিতে একাধিক লাইন থাকে, শেষ এক্সপ্রেশনটি রিটার্ন মান হয়ে যায়। যদি কোনো ফাংশন তার শেষ আর্গুমেন্ট হিসাবে lambda নেয়, এটি কল বন্ধনীর বাইরে সরানো যেতে পারে।

val sum: (Int, Int) -> Int = { a, b -> a + b }

// প্রসঙ্গ থেকে অনুমিত প্রকার
val sumShort = { a: Int, b: Int -> a + b }

// Lambda কল
val result = sum(5, 3)  // 8
println(result)

ভেরিয়েবল sum একটি স্পষ্ট কার্যকরী প্রকার (Int, Int) -> Int দিয়ে ঘোষিত এবং একটি lambda { a, b -> a + b } দিয়ে আরম্ভ করা হয়েছে। sumShort-এর জন্য, প্রকারগুলি lambda-এর ভিতরে নির্দিষ্ট এবং ভেরিয়েবলের প্রকার অনুমিত। উভয় রূপই সমতুল্য। lambda কল করা একটি সাধারণ ফাংশন কল করার থেকে আলাদা নয় — sum(5, 3) সিনট্যাক্স ব্যবহার করা। আর্গুমেন্ট ছাড়া lambda { body } হিসাবে লেখা হয়, একটি আর্গুমেন্ট সহ — { it -> it * 2 } বা শুধু { it * 2 }।

অন্তর্নিহিত it এবং আর্গুমেন্ট বাদ দেওয়া

যখন lambda ঠিক একটি আর্গুমেন্ট নেয়, Kotlin অন্তর্নিহিত নাম it প্রদান করে। এটি বাম পাশে আর্গুমেন্ট ঘোষণার প্রয়োজনীয়তা দূর করে। ডেভেলপার শুধু lambda বডি লেখে, একক প্যারামিটার অ্যাক্সেস করতে it ব্যবহার করে। এই সিনট্যাক্স বিশেষভাবে কালেকশন প্রসেসিং চেইনে সুবিধাজনক, যেখানে it বর্তমান উপাদানকে নির্দেশ করে।

val numbers = listOf(1, 2, 3, 4, 5)

// স্পষ্ট প্যারামিটার নাম
val squaredExplicit = numbers.map { n -> n * n }

// অন্তর্নিহিত it
val squared = numbers.map { it * it }

// it দিয়ে ফিল্টারিং
val even = numbers.filter { it % 2 == 0 }

println(squared) // [1, 4, 9, 16, 25]

উদাহরণে, map { it * it } n -> ঘোষণা করার পরিবর্তে it ব্যবহার করে। Kotlin স্বয়ংক্রিয়ভাবে একক lambda প্যারামিটারের জন্য it নির্ধারণ করে। যদি lambda দুই বা ততোধিক আর্গুমেন্ট নেয়, it তৈরি হয় না — সমস্ত প্যারামিটার স্পষ্টভাবে ঘোষণা করতে হবে। নেস্টেড lambdas-এর আরও ভাল পঠনযোগ্যতার জন্য, প্যারামিটারগুলিকে অর্থপূর্ণ নাম দেওয়া এবং শুধুমাত্র ছোট এক-লাইন প্রেডিকেটে it ব্যবহার করা উপযুক্ত।

Trailing lambda এবং বহু-লাইন lambdas

Trailing lambda হল Kotlin-এর একটি সিনট্যাক্টিক বৈশিষ্ট্য যা শেষ lambda আর্গুমেন্টকে ফাংশন কল বন্ধনীর বাইরে সরানোর অনুমতি দেয়। এটি কোডকে অন্তর্নির্মিত ভাষা নির্মাণের মতো করে তোলে। যদি lambda একমাত্র আর্গুমেন্ট হয়, বন্ধনী সম্পূর্ণভাবে বাদ দেওয়া যায়। এই পদ্ধতি স্ট্যান্ডার্ড লাইব্রেরি এবং DSL-এ সক্রিয়ভাবে ব্যবহৃত হয়।

// স্ট্যান্ডার্ড কল
thread(block = {
    println("থ্রেড থেকে হ্যালো")
})

// Trailing lambda সংস্করণ
thread {
    println("থ্রেড থেকে হ্যালো")
}

// trailing lambda সহ পুনরাবৃত্তি
repeat(3) { index ->
    println("পুনরাবৃত্তি $index")
}

// বহু-লাইন lambda সহ চালান
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

thread ফাংশন শেষ আর্গুমেন্ট হিসাবে Runnable গ্রহণ করে। trailing lambda-র কারণে, lambda বন্ধনীর বাইরে পাস করা যায়, যা দৃশ্যত একটি কোড ব্লকের মতো দেখায়। repeat ফাংশন পুনরাবৃত্তির সংখ্যা এবং একটি ইনডেক্স সহ lambda নেয়। run হল উচ্চ-ক্রম ফাংশনের একটি উদাহরণ যেখানে বহু-লাইন lambda শেষ এক্সপ্রেশন দ্বারা রিটার্ন করা মান গণনা করে। run()-এর চারপাশের বন্ধনী বাদ দেওয়া যেতে পারে যদি lambda একমাত্র আর্গুমেন্ট হয়।

lambdas-এ ভেরিয়েবল ক্যাপচার (closure)

ভেরিয়েবল ক্যাপচার (closure) হল lambda-র বাইরের স্কোপে ঘোষিত ভেরিয়েবল অ্যাক্সেস করার ক্ষমতা। Kotlin-এ, lambda var ভেরিয়েবল পড়তে এবং পরিবর্তন করতে পারে, পাশাপাশি আশেপাশের প্রসঙ্গ থেকে val ভেরিয়েবল পড়তে পারে। ক্যাপচার করা ভেরিয়েবলগুলি তাদের সমগ্র জীবনচক্র জুড়ে lambda-র সাথে সংরক্ষিত থাকে, যা অবস্থা সহ ফাংশন তৈরি করতে সক্ষম করে।

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // ক্যাপচার গণনা
    }
}

fun main() {
    val counter = makeCounter()
    println(counter()) // 0
    println(counter()) // 1
    println(counter()) // 2
}

makeCounter ফাংশন একটি স্থানীয় ভেরিয়েবল count ঘোষণা করে এবং একটি lambda { count++ } রিটার্ন করে। যদিও makeCounter এক্সিকিউশন সম্পন্ন করেছে, রিটার্ন করা lambda ক্লোজারের মাধ্যমে count-এর রেফারেন্স ধরে রাখে। counter()-এর প্রতিটি কল বর্তমান মান বৃদ্ধি করে এবং রিটার্ন করে। ক্লোজার মেকানিজম কারিিং, ফাংশন ফ্যাক্টরি এবং মেমোইজেশনের ভিত্তি। এটি মনে রাখা গুরুত্বপূর্ণ যে পরিবর্তনযোগ্য ভেরিয়েবল ক্যাপচার করা সমবর্তী এক্সিকিউশনে অপ্রত্যাশিত আচরণের কারণ হতে পারে।