Closures এবং Lambdas (ক্লোজারস এবং ল্যাম্বডাস)

ক্লোজারস (Closures) এবং ল্যাম্বডাস (Lambdas) রুবিতে ফাংশনাল প্রোগ্রামিং ধারণার অংশ হিসেবে ব্যবহৃত হয়। এই দুটি কনসেপ্ট ব্যবহারের মাধ্যমে আপনি প্রোগ্রামে ফাংশন এবং ব্লক কোড আরও শক্তিশালী, পঠনযোগ্য এবং পুনঃব্যবহারযোগ্য করতে পারেন। রুবিতে ক্লোজার এবং ল্যাম্বডা উভয়ই একইভাবে কোডের এক্সিকিউশন কন্ট্রোল করতে ব্যবহৃত হয়, তবে তাদের মধ্যে কিছু গুরুত্বপূর্ণ পার্থক্য রয়েছে।

১. Closures (ক্লোজারস)

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

উদাহরণ:

def outer
  x = 10
  inner = Proc.new { puts x }
  inner.call
end

outer  # Output: 10

এখানে, inner একটি Proc অবজেক্ট যা outer মেথডের স্কোপের ভ্যারিয়েবল x অ্যাক্সেস করতে পারে। যদিও x মেথডের বাইরে, inner ক্লোজারের মাধ্যমে সেটি ব্যবহার করা হয়েছে।

ক্লোজারসের এই বৈশিষ্ট্যই lexical scoping বা closure property নামে পরিচিত, যেখানে ফাংশন তার আর্গুমেন্ট এবং বাইরের স্কোপের ভ্যারিয়েবলগুলোকে স্মরণ রাখতে পারে।

২. Lambdas (ল্যাম্বডাস)

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

ল্যাম্বডা ডিফাইন করা (Defining a Lambda)

greet = lambda { |name| puts "Hello, #{name}!" }
greet.call("আজিজ")  # Output: Hello, আজিজ!

এখানে, lambda কিওয়ার্ড ব্যবহার করে একটি ফাংশন ডিফাইন করা হয়েছে, যা "Hello, #{name}!" মেসেজ প্রিন্ট করে।

ল্যাম্বডার বৈশিষ্ট্য

1. ফাংশনাল আচরণ: ল্যাম্বডাস ফাংশনগুলির মতো কাজ করে এবং আর্গুমেন্ট গ্রহণ করতে পারে।
2. return ব্যবহার: ল্যাম্বডার মধ্যে return ব্যবহার করলে এটি শুধুমাত্র সেই ল্যাম্বডার মধ্যে ফিরে যাবে, পুরো মেথডে ফিরে যাবে না।

def test_lambda
  greet = lambda { return "Returning from lambda" }
  result = greet.call
  puts result  # Output: Returning from lambda
  puts "End of method"
end

test_lambda

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

৩. Proc এবং Lambda এর মধ্যে পার্থক্য

রুবিতে, Proc এবং Lambda উভয়ই ক্লোজার, কিন্তু তাদের মধ্যে কিছু মূল পার্থক্য রয়েছে:

পার্থক্য ১: Return behavior

• Lambda: ল্যাম্বডা ফাংশনের মধ্যে return কেবলমাত্র ল্যাম্বডা থেকে বের করে। এটি মেথডের মধ্যে ফিরে যাবে না।
• Proc: Proc-এর মধ্যে return পুরো মেথডটি ত্যাগ করে, মানে ফাংশন থেকে বের হয়ে মেথডের এক্সিকিউশন বন্ধ করে দেয়।

def test_proc
  greet = Proc.new { return "Returning from Proc" }
  result = greet.call
  puts result
  puts "End of method"  # This line won't be executed
end

test_proc  # Output: Returning from Proc

এখানে, Proc-এর return মেথডের এক্সিকিউশনকেই বন্ধ করে দিয়েছে।

পার্থক্য ২: Argument checking

• Lambda: ল্যাম্বডা আর্গুমেন্টের সংখ্যা চেক করে এবং যদি সঠিক আর্গুমেন্ট না পায়, তবে ArgumentError তৈরি করবে।
• Proc: প্রোক আর্গুমেন্টের সংখ্যা না পেলেও এটি nil দিয়ে পূর্ণ করে কাজ করে।

# Lambda example
my_lambda = lambda { |x| puts x }
my_lambda.call(1)   # Works fine
# my_lambda.call     # Raises ArgumentError

# Proc example
my_proc = Proc.new { |x| puts x }
my_proc.call(1)     # Works fine
my_proc.call        # Output: nil

এখানে, ল্যাম্বডা আর্গুমেন্ট যাচাই করে ত্রুটি দেখায়, কিন্তু Proc আর্গুমেন্ট না পেলেও কাজ চালিয়ে যায়।

৪. Closures vs Lambdas (ক্লোজারস বনাম ল্যাম্বডাস)

• ক্লোজারস: ক্লোজার একটি ফাংশন যা বাইরের স্কোপের ভ্যারিয়েবল ধারণ করতে পারে, এবং এটি সাধারণত Proc অথবা blocks এর মাধ্যমে তৈরি হয়।
• ল্যাম্বডাস: ল্যাম্বডা একটি বিশেষ ধরনের ক্লোজার যা ফাংশনের মতো আচরণ করে এবং এর মধ্যে আর্গুমেন্ট যাচাই, return স্টেটমেন্টের আচরণ, এবং অন্যান্য ফাংশনাল বৈশিষ্ট্য থাকে।

উদাহরণ:

def outside_method
  x = 10
  # Closure example
  closure = Proc.new { puts x }
  closure.call  # Output: 10
end

outside_method

এখানে, ক্লোজার Proc.new ব্যবহার করে বাইরের স্কোপের ভ্যারিয়েবল x অ্যাক্সেস করা হয়েছে।

সারসংক্ষেপ

• ক্লোজারস: ফাংশন বা ব্লক যা বাইরের স্কোপের ভ্যারিয়েবলগুলি স্মরণ করতে পারে এবং অ্যাক্সেস করতে পারে।
• ল্যাম্বডাস: ফাংশনাল আচরণের মাধ্যমে আর্গুমেন্ট চেকিং, return এর আচরণ এবং অন্যান্য ফাংশনাল বৈশিষ্ট্য সরবরাহ করে। ল্যাম্বডাস lambda কিওয়ার্ড দিয়ে ডিফাইন করা হয় এবং এটি সাধারণত কোডের রিফ্যাক্টরিং এবং পুনঃব্যবহারযোগ্যতা বৃদ্ধির জন্য ব্যবহৃত হয়।
• Proc vs Lambda: ল্যাম্বডাস এবং প্রোকের মধ্যে পার্থক্য রয়েছে return এবং আর্গুমেন্ট চেকিং এর আচরণের ক্ষেত্রে।

রুবিতে ক্লোজারস এবং ল্যাম্বডাস ফাংশনাল প্রোগ্রামিং ধারণাকে কাজে লাগিয়ে কোডের কার্যক্ষমতা, পুনঃব্যবহারযোগ্যতা এবং ক্লিন কোড লেখা সহজ করে তোলে।

Closures প্রোগ্রামিংয়ের একটি শক্তিশালী ধারণা, যা রুবি সহ অনেক প্রোগ্রামিং ভাষায় ব্যবহৃত হয়। Closure হল এমন একটি ফাংশন (বা ব্লক) যা তার বাইরের স্কোপের ভেরিয়েবলগুলি মনে রাখে এবং সেগুলি ব্যবহার করতে সক্ষম হয়। সহজভাবে বললে, একটি ক্লোজার হল একটি ফাংশন যা তার নিজের লজিক ছাড়াও বাইরের ভেরিয়েবল বা আর্গুমেন্টের উপর ভিত্তি করে কাজ করে।

রুবিতে blocks, procs, এবং lambdas ক্লোজার হিসাবে কাজ করে।

Closures এর মৌলিক ধারণা

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

রুবিতে closures সাধারণত blocks, procs, এবং lambdas এর মাধ্যমে তৈরি করা হয়।

Closures এর উদাহরণ: Blocks, Procs, and Lambdas

1. Blocks

রুবিতে ব্লকগুলি হল ক্লোজার তৈরি করার একটি জনপ্রিয় পদ্ধতি। ব্লক সাধারণত মেথড কলের সাথে যুক্ত হয় এবং তাতে প্যারামিটার গ্রহণ করতে পারে। ব্লক নিজে একটি ক্লোজার হতে পারে, কারণ এটি বাইরের স্কোপের ভেরিয়েবলকে "মনে রাখে"।

উদাহরণ:

def greeting(name)
  # ব্লক হিসেবে ক্লোজার
  yield(name) if block_given?
end

name = "আজিজ"
greeting(name) { |n| puts "Hello, #{n}!" }

এখানে, greeting মেথডে একটি ব্লক দেওয়া হয়েছে, যা name প্যারামিটারটি গ্রহণ করে এবং তার উপর কাজ করে। ব্লকটি বাইরের name ভেরিয়েবলকে মনে রেখেছে এবং সঠিকভাবে কাজ করেছে।

আউটপুট:

Hello, আজিজ!

2. Procs

Proc হল একটি অবজেক্ট যা একটি ব্লক ধারণ করে এবং এটি ফাংশনের মতো ব্যবহার করা যায়। প্রোকস হল একটি ক্লোজার, কারণ এটি নিজের বাইরের স্কোপের ভেরিয়েবলগুলির সাথে সম্পর্ক রাখতে পারে।

উদাহরণ:

def make_multiplier(factor)
  # প্রোক তৈরি করা
  Proc.new { |n| n * factor }
end

double = make_multiplier(2)
puts double.call(5)  # আউটপুট: 10

এখানে, make_multiplier মেথড একটি প্রোক তৈরি করছে, যা বাইরের স্কোপের factor ভেরিয়েবলকে মনে রাখে এবং তার ভিত্তিতে গুণফল বের করে। প্রোকটি পরবর্তীতে call মেথড দিয়ে ব্যবহার করা হয়।

আউটপুট:

10

3. Lambdas

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

উদাহরণ:

multiply = lambda { |a, b| a * b }
puts multiply.call(2, 3)  # আউটপুট: 6

এখানে, lambda একটি ফাংশন তৈরি করেছে যা দুইটি প্যারামিটার গ্রহণ করে এবং তাদের গুণফল বের করে। call মেথড ব্যবহার করে এটি চালানো হয়েছে।

Lambda vs Proc

• Proc: একটি প্রোক একটি ক্লোজার হিসেবে কাজ করতে পারে, তবে এটি প্যারামিটার চেক করে না এবং অতিরিক্ত প্যারামিটার গ্রহণ করলেও কাজ করতে থাকে।
• Lambda: ল্যাম্বডার প্যারামিটার চেকিং রয়েছে এবং অতিরিক্ত প্যারামিটার দিলে ত্রুটি দেখায়।

উদাহরণ:

# Proc Example
proc_example = Proc.new { |a, b| a + b }
puts proc_example.call(1)  # আউটপুট: 1 (b প্যারামিটার অনুপস্থিত)
puts proc_example.call(1, 2)  # আউটপুট: 3

# Lambda Example
lambda_example = lambda { |a, b| a + b }
puts lambda_example.call(1)  # ত্রুটি: wrong number of arguments (1 for 2)

এখানে, প্রোক extra প্যারামিটার গ্রহণ করলেও কোনো সমস্যা হয় না, কিন্তু ল্যাম্বা অতিরিক্ত প্যারামিটার দিলে ত্রুটি দেখায়।

Closures এর ব্যবহার

1. স্কোপে ভেরিয়েবল ব্যবহার: ক্লোজারের মধ্যে বাইরের স্কোপের ভেরিয়েবল ব্যবহার করা হয়।
2. ফাংশনাল প্রোগ্রামিং: ফাংশনাল প্রোগ্রামিংয়ের মতো প্যারামিটার হিসেবে ক্লোজার প্রেরণ করা এবং তার উপর ভিত্তি করে কাজ করা।
3. কাস্টম লজিক প্রক্রিয়া: অনেক সময় ক্লোজার ব্যবহার করে কাস্টম লজিক তৈরি করা হয় যেখানে বাইরের স্কোপের পরিবর্তনশীলতা রাখা হয়।

Closures এর সুবিধা

1. কোড পুনঃব্যবহারযোগ্যতা: ক্লোজার আপনাকে একই লজিক বিভিন্ন জায়গায় পুনরায় ব্যবহার করার সুবিধা দেয়।
2. স্কোপ সংরক্ষণ: ক্লোজার বাইরের স্কোপের ভেরিয়েবলকে মনে রাখে, যা অনেক ক্ষেত্রে কার্যকরী হতে পারে।
3. ফাংশনাল প্রোগ্রামিং: ক্লোজারগুলি ফাংশনাল প্রোগ্রামিংয়ের মৌলিক বৈশিষ্ট্য, যেখানে ফাংশনকে আরেকটি ফাংশনের প্যারামিটার হিসেবে ব্যবহার করা যায়।

সারসংক্ষেপ

• Closures হল ফাংশন বা ব্লক যা বাইরের স্কোপের ভেরিয়েবলকে মনে রাখে এবং সেগুলির উপর কাজ করতে পারে।
• রুবিতে blocks, procs, এবং lambdas ক্লোজার হিসাবে কাজ করে।
• Blocks হল এমন ফাংশন যা একটি মেথডের সঙ্গে সংযুক্ত থাকে এবং তার বাইরের ভেরিয়েবল ব্যবহার করতে পারে।
• Procs এবং Lambdas হল ফাংশনাল অবজেক্ট যা বাইরের স্কোপের ভেরিয়েবল ব্যবহার করতে পারে, তবে সেগুলির মধ্যে কিছু পার্থক্য আছে, যেমন প্যারামিটার চেকিং।

Procs এবং Lambdas উভয়ই রুবি প্রোগ্রামিং ভাষায় ফাংশনাল প্রোগ্রামিংয়ের অংশ হিসেবে ব্যবহৃত হয়, এবং এগুলোর মাধ্যমে কোডের পুনঃব্যবহারযোগ্যতা এবং কার্যকারিতা বৃদ্ধি করা যায়। তবে, Procs এবং Lambdas এর মধ্যে কিছু গুরুত্বপূর্ণ পার্থক্য রয়েছে, যা তাদের ব্যবহার এবং আচরণকে পৃথক করে।

১. Syntax এবং Definition

Proc (প্রক)

Proc হল একটি অবজেক্ট, যা রুবির মধ্যে ফাংশন হিসেবে কাজ করে। এটি সাধারণত Proc.new অথবা proc কিওয়ার্ড দিয়ে তৈরি করা হয়। প্রোক্স একটি কোড ব্লক ধারণ করে, এবং এটি মেথডে পাস করা যায়।

# Creating a Proc using Proc.new
my_proc = Proc.new { |x| puts "Hello, #{x}" }

# OR Creating a Proc using proc shorthand
my_proc = proc { |x| puts "Hello, #{x}" }

Lambda (ল্যাম্বডা)

Lambda হল একটি বিশেষ ধরনের Proc, যা নির্দিষ্ট কিছু নিয়ম অনুযায়ী কাজ করে। এটি সাধারণত lambda কিওয়ার্ড দিয়ে তৈরি করা হয়। ল্যাম্বডা এমন একটি ব্লক যা ফাংশন হিসেবে কাজ করে এবং এটি ফাংশনের মতো আচরণ করে।

# Creating a Lambda
my_lambda = lambda { |x| puts "Hello, #{x}" }

# OR Creating a Lambda using -> shorthand
my_lambda = ->(x) { puts "Hello, #{x}" }

২. Parameters Handling

Proc

Proc এর জন্য প্যারামিটার ব্যবহারের ক্ষেত্রে একটি গুরুত্বপূর্ণ পার্থক্য হল, এটি অপ্রত্যাশিত প্যারামিটার গ্রহণ করতে পারে। এটি যদি প্রাপ্ত প্যারামিটার দিয়ে কোনো কোড না চলে, তবে এটি কোনো ত্রুটি (error) উৎপন্ন করবে না, বরং nil ফেরত দেবে।

# Proc Example
my_proc = Proc.new { |x, y| puts "Hello, #{x}, #{y}" }

my_proc.call("Alice")  # Output: Hello, Alice, 

এখানে, যেহেতু y প্যারামিটারটি সরবরাহ করা হয়নি, তাই y এর মান nil হবে এবং কোডটি Hello, Alice, nil আউটপুট করবে।

Lambda

Lambda প্যারামিটার চেকিংয়ের ক্ষেত্রে বেশি কড়া। এটি নির্দিষ্ট প্যারামিটার সংখ্যা চেক করে এবং যদি সেই সংখ্যা পূর্ণ না হয়, তাহলে একটি ArgumentError সৃষ্টি করবে।

# Lambda Example
my_lambda = lambda { |x, y| puts "Hello, #{x}, #{y}" }

my_lambda.call("Alice")  # Error: wrong number of arguments (given 1, expected 2)

এখানে, ল্যাম্বডা x এবং y দুইটি প্যারামিটার আশা করছে, কিন্তু y প্যারামিটারটি সরবরাহ না করা হলে একটি ত্রুটি ঘটবে।

৩. Return Behavior

Proc

Proc যখন একটি return কমান্ড ব্যবহার করে, তখন এটি মেথডের মধ্যে return কমান্ডটিকে প্রভাবিত করতে পারে। এটি outer method বা প্রেক্ষিতের মধ্যে রিটার্ন নিয়ে যেতে পারে, যা কোডের 흐ামান্বয়কে বন্ধ করে দেয়।

def my_method
  my_proc = Proc.new { return "Returning from Proc!" }
  my_proc.call
  puts "This will never be printed."
end

puts my_method  # Output: Returning from Proc!

এখানে, my_proc.call এর মাধ্যমে return কমান্ড মেথডের বাইরে চলে গেছে এবং "This will never be printed." কখনোই মুদ্রিত হয়নি।

Lambda

Lambda একটি সাধারণ ফাংশনের মতো আচরণ করে এবং এটি ফাংশন স্কোপ রিটার্ন করে। return কমান্ড lambda এর নিজস্ব স্কোপে কাজ করে এবং বাহ্যিক মেথডের কার্যক্রম প্রভাবিত করে না।

def my_method
  my_lambda = lambda { return "Returning from Lambda!" }
  my_lambda.call
  puts "This will be printed."
end

puts my_method  # Output: This will be printed.

এখানে, ল্যাম্বডা ফাংশনের মধ্যে return কমান্ড ব্যবহার করা হয়েছে, কিন্তু এটি শুধুমাত্র ল্যাম্বডার স্কোপে কাজ করেছে, বাহ্যিক মেথডে কোনো প্রভাব ফেলেনি।

৪. Performance

এটি বলে দেওয়া যেতে পারে যে, Lambdas সাধারণত Procs থেকে একটু বেশি কার্যকরী (performant), কারণ Lambdas ফাংশনের মতো আচরণ করে এবং এটি প্যারামিটার চেকিং করে, যা একটি নিয়ন্ত্রিত পরিবেশে দ্রুত কাজ করে। অন্যদিকে, Procs কিছুটা নমনীয় এবং এটি প্যারামিটার চেকিং কম করে।

5. Summary of Differences

Conclusion

• Procs: একাধিক প্যারামিটার গ্রহণ করতে পারে এবং তার প্যারামিটার চেকিং খুবই নমনীয়। return কমান্ড ব্যবহার করলে এটি বাহ্যিক মেথডকে প্রভাবিত করে।
• Lambdas: সঠিক প্যারামিটার চেকিং করে এবং একটি সাধারণ ফাংশনের মতো আচরণ করে, যেখানে return শুধুমাত্র ল্যাম্বডার স্কোপে কাজ করে।

Lambdas তখন ব্যবহার করা উচিত যখন আপনি প্যারামিটার চেকিং এবং একটি নির্দিষ্ট স্কোপে ফাংশনাল আচরণ চান, এবং Procs তখন ব্যবহার করা উচিত যখন কোডের পুনঃব্যবহারযোগ্যতা এবং নমনীয়তা চাচ্ছেন।

Functional Programming (FP) হচ্ছে একটি প্রোগ্রামিং প্যারাডাইম যেখানে ফাংশনগুলি first-class citizens হিসেবে ব্যবহৃত হয় এবং কোডের মধ্যে পার্শ্বপ্রতিক্রিয়া (side-effects) কম করার চেষ্টা করা হয়। রুবি, যদিও প্রধানত Object-Oriented Programming (OOP) ভাষা, তবুও এতে functional programming এর কিছু ধারণা সমর্থিত আছে, যেমন closures, lambdas, এবং blocks।

এখানে আমরা closures এবং lambdas এর মাধ্যমে functional programming এর ধারণা এবং তাদের ব্যবহার বুঝে নিব।

১. Closures (ক্লোজার)

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

রুবিতে, closures মূলত blocks, lambdas, এবং procs এর মাধ্যমে ব্যবহার করা হয়।

উদাহরণ:

def outer
  x = 10  # outer scope variable
  # defining a closure
  return Proc.new { puts "The value of x is #{x}" }
end

closure = outer  # assign the closure
closure.call  # Output: The value of x is 10

এখানে, Proc.new একটি closure তৈরি করছে, যা outer ফাংশনের ভিতরের x ভেরিয়েবলটি ব্যবহার করতে পারে। যখন closure.call কল করা হয়, তখন এটি তার নিজস্ব scope এবং বাইরের scope উভয়েই অ্যাক্সেস পায়।

২. Lambdas in Ruby (ল্যাম্বডা)

Lambdas হল বিশেষ ধরনের closures, যা ফাংশনাল প্রোগ্রামিংয়ে ব্যবহৃত হয়। ল্যাম্বডা একটি ব্লক বা প্রক্রিয়া যা একটি ফাংশনের মতো কাজ করে, এবং এটি কোডের নির্দিষ্ট অংশকে পুনঃব্যবহারযোগ্যভাবে পাস করা সম্ভব করে তোলে। রুবিতে lambdas তৈরি করতে lambda বা -> সিনট্যাক্স ব্যবহার করা হয়।

Syntax:

lambda = lambda { |parameters| # code block }

এছাড়া, -> সিনট্যাক্সও ল্যাম্বডা তৈরি করার জন্য ব্যবহৃত হতে পারে:

lambda = ->(parameters) { # code block }

উদাহরণ:

# Using `lambda` syntax
greet = lambda { |name| puts "Hello, #{name}!" }

greet.call("Alice")  # Output: Hello, Alice!

# Using `->` syntax
sum = ->(a, b) { a + b }

puts sum.call(5, 3)  # Output: 8

এখানে:

• greet ল্যাম্বডা একটি নাম প্যারামিটার নিয়ে একটি মেসেজ প্রিন্ট করে।
• sum ল্যাম্বডা দুটি প্যারামিটার নিয়ে তাদের যোগফল প্রদান করে।

৩. Difference between Proc and Lambda

রুবিতে Procs এবং Lambdas উভয়ই closures, কিন্তু তাদের মধ্যে কিছু পার্থক্য রয়েছে:

• Return Behavior: lambda তে return ব্যবহারের ফলে ল্যাম্বডা কল করা ব্লকটি শেষ হয়, কিন্তু Proc তে return পুরো enclosing method বা function কে প্রভাবিত করে।
• Argument Checking: lambda প্যারামিটার চেক করে এবং যদি ভুল সংখ্যা প্যারামিটার পাস করা হয়, তবে ত্রুটি (error) প্রদর্শন করে। কিন্তু Proc তে অতিরিক্ত প্যারামিটার পাঠানো হলে, তা nil হিসেবে গণ্য হয়।

উদাহরণ:

# Lambda example
test_lambda = lambda { |x| puts x }
test_lambda.call(1)   # Output: 1
test_lambda.call(1, 2)  # Error: wrong number of arguments (1 for 2)

# Proc example
test_proc = Proc.new { |x| puts x }
test_proc.call(1)    # Output: 1
test_proc.call(1, 2) # Output: 1 (ignores extra argument)

এখানে:

• lambda তে অতিরিক্ত আর্গুমেন্ট পাস করা হলে ত্রুটি ঘটবে, কিন্তু Proc তে তা উপেক্ষা করা হয়।

৪. Functional Programming with Closures and Lambdas

Closures এবং lambdas রুবিতে ফাংশনাল প্রোগ্রামিংয়ের মূল উপাদান, কারণ এগুলো আপনাকে কোডের বিভিন্ন অংশকে একটি ব্লক আকারে পাস করতে এবং পুনঃব্যবহারযোগ্য ফাংশন তৈরি করতে সহায়তা করে। এদের মাধ্যমে কোডের কার্যকারিতা সহজে প্রসারিত করা যায় এবং নতুন বৈশিষ্ট্য যোগ করা সম্ভব হয়।

উদাহরণ: Higher-Order Functions

একটি Higher-Order Function এমন একটি ফাংশন যা অন্য ফাংশন গ্রহণ করে বা ফেরত দেয়। রুবিতে, lambdas এবং procs এর মাধ্যমে আপনি এই ধরনের ফাংশন তৈরি করতে পারেন।

def apply_function(num, func)
  func.call(num)
end

multiply = lambda { |x| x * 2 }

puts apply_function(5, multiply)  # Output: 10

এখানে, apply_function একটি higher-order function, যা ল্যাম্বডা ফাংশন প্যারামিটার হিসেবে গ্রহণ করছে এবং তার মাধ্যমে একটি গুণফল প্রদান করছে।

৫. Advantages of Closures and Lambdas in Functional Programming

• Reusability: কোডের পুনঃব্যবহারযোগ্যতা বৃদ্ধি পায়, কারণ আপনি ফাংশন বা কোডের অংশ অন্য ফাংশনে পাস করতে পারেন।
• Encapsulation: closures ফাংশনাল প্রোগ্রামিংয়ের একটি শক্তিশালী কৌশল, যা ডেটা এনক্যাপসুলেশন নিশ্চিত করে এবং কোডের নির্দিষ্ট অংশ লুকানো রাখে।
• Cleaner Code: কোডে ফাংশন এবং ল্যাম্বডা ব্যবহারের মাধ্যমে জটিলতা কমিয়ে কোড পরিষ্কার এবং সহজবোধ্য করা সম্ভব।
• Efficient Functional Composition: আপনি বিভিন্ন ফাংশনকে একসাথে জুড়ে নতুন কার্যকারিতা তৈরি করতে পারেন।

সারসংক্ষেপ

• Closures রুবিতে ফাংশনের ভিতরে একটি কোড ব্লক হিসেবে কাজ করে, যা বাইরের ভেরিয়েবলগুলোকে ধারণ করে। এটি ডেটার এনক্যাপসুলেশন এবং কোডের পুনঃব্যবহারযোগ্যতা বাড়াতে ব্যবহৃত হয়।
• Lambdas হল একটি বিশেষ ধরনের closure যা ফাংশনের মতো কাজ করে এবং আর্গুমেন্টের সংখ্যা চেক করে।
• Procs এবং Lambdas উভয়ই closures, তবে তাদের আচরণে কিছু পার্থক্য রয়েছে (যেমন আর্গুমেন্ট চেকিং এবং return ব্যবহারে পার্থক্য)।
• Functional Programming-এ closures এবং lambdas ব্যবহারের মাধ্যমে আপনি কোডের পুনঃব্যবহারযোগ্যতা, নির্দিষ্টতা এবং কার্যকারিতা বৃদ্ধি করতে পারেন।

এগুলি রুবি প্রোগ্রামিং ভাষায় functional programming এর ধারণা এবং উপকারিতা কার্যকরভাবে বাস্তবায়ন করতে সহায়তা করে।

Lambdas হল রুবিতে একটি বিশেষ ধরনের Proc যা ফাংশনাল প্রোগ্রামিংয়ের ধারণা অনুসরণ করে। একটি lambda হল একটি anonymous function (নামবিহীন ফাংশন), যা একটি পরিবর্তনশীল সংখ্যা বা আর্গুমেন্ট গ্রহণ করতে পারে এবং একটি Proc অবজেক্ট হিসেবে কাজ করে।

১. Lambda Syntax

রুবিতে lambda তৈরি করার জন্য দুটি প্রধান উপায় রয়েছে:

1. lambda মেথড ব্যবহার করে
2. -> (stabby lambda) ব্যবহার করে

Syntax ১: lambda মেথড ব্যবহার করে

my_lambda = lambda { |arg1, arg2| 
  # function body
  puts "Argument 1: #{arg1}, Argument 2: #{arg2}"
}

Syntax ২: -> (stabby lambda) ব্যবহার করে

my_lambda = -> (arg1, arg2) { 
  # function body
  puts "Argument 1: #{arg1}, Argument 2: #{arg2}"
}

২. Lambda Function উদাহরণ

এখন, আমরা কিছু উদাহরণ দেখি, যেখানে ল্যাম্বডা ব্যবহৃত হচ্ছে।

উদাহরণ ১: একটি সাধারণ Lambda

# Lambda creation
my_lambda = lambda { |x| puts "The value of x is #{x}" }

# Calling the lambda
my_lambda.call(10)  # Output: The value of x is 10

এখানে, একটি lambda তৈরি করা হয়েছে যা একটি আর্গুমেন্ট x গ্রহণ করে এবং সেটির মান আউটপুট করে। পরে call মেথডের মাধ্যমে ল্যাম্বডাটি কল করা হয়েছে।

উদাহরণ ২: Multiple Arguments সহ Lambda

# Lambda with multiple arguments
my_lambda = lambda { |x, y| puts "Sum of x and y is #{x + y}" }

# Calling the lambda
my_lambda.call(5, 3)  # Output: Sum of x and y is 8

এখানে, ল্যাম্বডাটি দুটি আর্গুমেন্ট (x এবং y) গ্রহণ করছে এবং তাদের যোগফল আউটপুট করছে।

উদাহরণ ৩: Return Behavior in Lambda vs Proc

একটি গুরুত্বপূর্ণ পার্থক্য হলো lambda এবং proc এর return আচরণ। Lambda-তে return শুধুমাত্র ল্যাম্বডার ভিতর থেকে বের হয়ে যায়, কিন্তু Proc-এ return মেথডটি পুরো মেথড বা ব্লক থেকে বেরিয়ে আসে।

def test_lambda
  my_lambda = lambda { return "Returned from lambda" }
  puts my_lambda.call
  puts "After lambda"
end

test_lambda

আউটপুট:

Returned from lambda
After lambda

এখানে, return শুধুমাত্র ল্যাম্বডার ভিতরেই কাজ করছে এবং পুরো মেথডে চলে যাচ্ছে না। puts এর মাধ্যমে পরবর্তী লাইনের কোডও কার্যকর হতে পারে।

উদাহরণ ৪: lambda এবং proc এর পার্থক্য

def test_proc
  my_proc = Proc.new { return "Returned from proc" }
  puts my_proc.call
  puts "After proc"
end

test_proc

আউটপুট:

Returned from proc

এখানে, Proc এর return মেথডটি পুরো test_proc মেথড থেকে বের হয়ে গেছে এবং পরবর্তী কোড কার্যকর হয়নি।

৩. Lambda vs Proc

সারসংক্ষেপ

• Lambda রুবিতে একটি অ্যানোনিমাস ফাংশন, যা আর্গুমেন্ট গ্রহণ করতে পারে এবং সাধারণত একটি Proc অবজেক্ট হিসেবে কাজ করে।
• রুবিতে lambda তৈরি করার জন্য দুটি প্রধান পদ্ধতি রয়েছে: lambda {} এবং -> {}।
• Lambda এবং Proc এর মধ্যে একটি প্রধান পার্থক্য হল return behavior।
• Lambda সাধারণত ফাংশনাল প্রোগ্রামিংয়ের জন্য ব্যবহৃত হয় এবং এটি কোডে আর্গুমেন্ট চেকিং এবং আরও সুনির্দিষ্ট আচরণ প্রদান করে।