Control Flow Statements (নিয়ন্ত্রণ প্রবাহ স্টেটমেন্টস)

Control Flow Statements in Haskell (নিয়ন্ত্রণ প্রবাহ স্টেটমেন্টস)

Haskell একটি ফাংশনাল প্রোগ্রামিং ভাষা হওয়ায়, এখানে সাধারণত অলিভ ফাংশনাল স্টাইল নিয়ন্ত্রণ প্রবাহ (control flow) পরিচালনা করা হয়। অন্যান্য Imperative ভাষার মতো explicit control flow structures (যেমন if-else, for বা while loops) Haskell এ সরাসরি পাওয়া যায় না, তবে Haskell এ কিছু শক্তিশালী ফাংশনাল কৌশল রয়েছে, যেমন গার্ডস (Guards), প্যাটার্ন ম্যাচিং (Pattern Matching), এবং লাইব্রেরি ফাংশন যা নিয়ন্ত্রণ প্রবাহকে নির্ধারণ করে।

এখানে আমরা Haskell এর বিভিন্ন নিয়ন্ত্রণ প্রবাহ স্টেটমেন্ট এবং তাদের ব্যবহার নিয়ে আলোচনা করব।

১. If-Else Statement (ইফ-এলস স্টেটমেন্ট)

Haskell এ if-else স্টেটমেন্ট একটি শর্তের ভিত্তিতে বিভিন্ন কোড এক্সিকিউট করতে ব্যবহৃত হয়। সাধারণত, if-else একটি একক এক্সপ্রেশন হিসেবে কাজ করে, অর্থাৎ if এবং else এর মধ্যে যে কোড লেখা হয় তা সমস্তই একটি একক এক্সপ্রেশন হিসাবে মূল্যায়িত হয়।

maxNum :: Int -> Int -> Int
maxNum x y = if x > y then x else y

এখানে:

• maxNum একটি ফাংশন যা দুটি পূর্ণসংখ্যা নেয় এবং বড় সংখ্যা ফেরত দেয়।
• if x > y then x else y শর্তে যদি x ছোট হয় তাহলে y ফেরত দেওয়া হবে, অন্যথায় x ফেরত দেবে।

উদাহরণ:

result = maxNum 5 10
-- result will be 10

এখানে:

• maxNum 5 10 এর ফলাফল হবে 10।

২. Guards (গার্ডস)

গার্ডস Haskell এ একটি শক্তিশালী নিয়ন্ত্রণ প্রবাহ কৌশল যা if-else এর তুলনায় আরও পরিষ্কার এবং ব্যবহারযোগ্য। গার্ডস ব্যবহার করে আমরা শর্ত প্রদান করতে পারি, যা প্যাটার্ন ম্যাচিংয়ের মতো কোডকে আরও সহজ ও স্পষ্ট করে তোলে।

absoluteValue :: Int -> Int
absoluteValue x
  | x >= 0    = x
  | otherwise = -x

এখানে:

• absoluteValue একটি ফাংশন যা x এর আপেক্ষিক মান প্রদান করে।
• | চিহ্ন দিয়ে শর্ত এবং তার ফলাফল উল্লেখ করা হয়েছে।
• otherwise হলো একটি পূর্বনির্ধারিত শর্ত যা অন্য কোন শর্তের সাথে মেলেনি এমন ক্ষেত্রে ব্যবহার করা হয়।

উদাহরণ:

result = absoluteValue (-5)
-- result will be 5

এখানে:

• absoluteValue (-5) এর ফলাফল হবে 5।

৩. Pattern Matching (প্যাটার্ন ম্যাচিং)

Haskell এ প্যাটার্ন ম্যাচিং একটি অত্যন্ত শক্তিশালী নিয়ন্ত্রণ প্রবাহ কৌশল। এটি ফাংশনগুলির বিভিন্ন শাখার জন্য বিভিন্ন আর্গুমেন্টের মান অনুযায়ী কোড এক্সিকিউট করতে সহায়ক।

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

এখানে:

• factorial 0 = 1: 0 এর জন্য ফ্যাক্টোরিয়াল 1 হবে।
• factorial n = n * factorial (n - 1): অন্য যেকোনো মানের জন্য, ফ্যাক্টোরিয়াল n হবে n * (n - 1) এর ফ্যাক্টোরিয়ালের সমান।

উদাহরণ:

result = factorial 5
-- result will be 120

এখানে:

• factorial 5 এর ফলাফল হবে 120।

৪. Let-In Expressions (লেট-ইন এক্সপ্রেশন)

let হল একটি নিয়ন্ত্রণ প্রবাহ কৌশল যা লোকাল ভেরিয়েবল ডিফাইন করতে ব্যবহৃত হয়। এটি সাধারণত একটি এক্সপ্রেশনের মধ্যে ভেরিয়েবল ডিফাইন করতে ব্যবহৃত হয়, যেখানে তার মান অন্যান্য এক্সপ্রেশনগুলোতে ব্যবহার করা যায়।

calculateArea :: Float -> Float -> Float
calculateArea length width = let area = length * width
                              in area

এখানে:

• let area = length * width একটি স্থানীয় ভেরিয়েবল তৈরি করছে এবং এর মান length * width।
• in area এ ভেরিয়েবলটি ব্যবহার করা হচ্ছে এবং এটি আউটপুট হিসেবে প্রদান করা হচ্ছে।

উদাহরণ:

result = calculateArea 5 3
-- result will be 15

এখানে:

• calculateArea 5 3 এর ফলাফল হবে 15।

৫. Case Expressions (কেস এক্সপ্রেশন)

case এক্সপ্রেশন Haskell এ একটি বিশেষ নিয়ন্ত্রণ প্রবাহ কৌশল যা একটি একক এক্সপ্রেশনকে বিভিন্ন প্যাটার্নের সাথে তুলনা করে বিভিন্ন আউটপুট প্রদান করতে সাহায্য করে।

describeNumber :: Int -> String
describeNumber x = case x of
    0 -> "Zero"
    1 -> "One"
    _ -> "Other"

এখানে:

• describeNumber একটি ফাংশন যা একটি পূর্ণসংখ্যা নিয়ে, তার মান অনুসারে একটি স্ট্রিং প্রদান করে।
• case x of এর মাধ্যমে x এর মানের ভিত্তিতে বিভিন্ন শাখায় কোড এক্সিকিউট হয়।
• _ (অ্যাডিওশনাল প্যাটার্ন) মানে হলো কোন শর্তের সাথে না মিললে এটি কার্যকর হবে।

উদাহরণ:

result = describeNumber 2
-- result will be "Other"

এখানে:

• describeNumber 2 এর ফলাফল হবে "Other" কারণ 2 কোনো নির্দিষ্ট শর্তের সাথে মেলে না।

৬. While Loops (হোয়াইল লুপ)

Haskell একটি ফাংশনাল ভাষা হওয়ায় while loop বা for loop এর মতো imperative loop structures সরাসরি ব্যবহার করা যায় না। তবে tail recursion ব্যবহার করে এমন কার্যকরী পুনরাবৃত্তি তৈরি করা সম্ভব।

sumUpTo :: Int -> Int
sumUpTo n = sumHelper n 0
  where
    sumHelper 0 total = total
    sumHelper n total = sumHelper (n - 1) (total + n)

এখানে:

• sumHelper একটি পুনরাবৃত্তি ফাংশন যা n পর্যন্ত সব সংখ্যা যোগফল করে।

উদাহরণ:

result = sumUpTo 5
-- result will be 15

এখানে:

• sumUpTo 5 এর ফলাফল হবে 15 (যেমন 5 + 4 + 3 + 2 + 1 = 15)।

উপসংহার

Haskell এ নিয়ন্ত্রণ প্রবাহ স্টেটমেন্টগুলি মূলত ফাংশনাল প্রোগ্রামিং কৌশলগুলির মাধ্যমে পরিচালিত হয়, যেখানে প্যাটার্ন ম্যাচিং, গার্ডস, কেস এক্সপ্রেশন এবং লেট-ইন এক্সপ্রেশন ব্যবহার করা হয়। এই কৌশলগুলির মাধ্যমে কোডে শর্তাধীন কার্যকলাপ এবং পুনরাবৃত্তি সহজে পরিচালনা করা যায়, যা কোডের পাঠযোগ্যতা এবং কার্যকারিতা বাড়ায়। Haskell এ এফেক্টিভ নিয়ন্ত্রণ প্রবাহ ব্যবহারের ফলে প্রোগ্রাম আরও পরিষ্কার, নির্ভরযোগ্য এবং রক্ষণাবেক্ষণযোগ্য হয়।

Haskell এ if, then, else স্টেটমেন্ট

Haskell এ if, then, এবং else স্টেটমেন্ট কন্ডিশনাল এক্সপ্রেশন তৈরি করতে ব্যবহৃত হয়। যেহেতু Haskell একটি ফাংশনাল ভাষা, তাই এখানে if স্টেটমেন্টের পরে then এবং else অংশ থাকা আবশ্যক, কারণ Haskell এ প্রতিটি if এক্সপ্রেশনের একটি ফলাফল বা আউটপুট থাকতে হবে। if এক্সপ্রেশন ব্যবহার করে শর্তানুযায়ী প্রোগ্রামের বিভিন্ন লজিক পরিচালনা করা হয়।

Haskell এ if এক্সপ্রেশনের সাধারণ গঠন হলো:

if condition then result1 else result2

এখানে:

• condition: শর্ত, যা True বা False হতে পারে।
• result1: যদি condition True হয়, তবে এটি রিটার্ন করবে।
• result2: যদি condition False হয়, তবে এটি রিটার্ন করবে।

উদাহরণ ১: একটি সাধারণ if এক্সপ্রেশন

নিচে একটি উদাহরণ দেওয়া হলো যেখানে if এক্সপ্রেশন ব্যবহার করে একটি সংখ্যা ধনাত্মক বা ঋণাত্মক তা যাচাই করা হয়েছে।

checkNumber :: Int -> String
checkNumber x = if x > 0 then "Positive" else "Negative or Zero"

এখানে:

• x > 0 শর্তটি যাচাই করা হয়েছে।
• যদি x > 0 হয়, তাহলে "Positive" রিটার্ন হবে।
• অন্যথায় "Negative or Zero" রিটার্ন হবে।

উদাহরণ ২: if এক্সপ্রেশন ব্যবহার করে Absolute Value ফাংশন

নিচে if, then, এবং else স্টেটমেন্ট ব্যবহার করে একটি সংখ্যা ধনাত্মক মান বের করার উদাহরণ দেওয়া হলো।

absolute :: Int -> Int
absolute x = if x < 0 then -x else x

এখানে:

• যদি x < 0 হয়, তাহলে -x রিটার্ন হবে, অর্থাৎ ঋণাত্মক সংখ্যাকে ধনাত্মক করা হবে।
• অন্যথায় x রিটার্ন হবে।

উদাহরণ ৩: if, then, else এক্সপ্রেশন একটি লম্বা কন্ডিশনের জন্য

একটি সংখ্যা ধনাত্মক, ঋণাত্মক বা শূন্য তা নির্ধারণ করতে if স্টেটমেন্ট ব্যবহার করা যেতে পারে।

checkSign :: Int -> String
checkSign x = if x > 0
              then "Positive"
              else if x < 0
                   then "Negative"
                   else "Zero"

এখানে:

• প্রথমে, if x > 0 শর্তটি যাচাই করা হয়েছে, এবং যদি এটি True হয়, তাহলে "Positive" রিটার্ন হবে।
• যদি x > 0 শর্তটি False হয়, তবে এটি পরবর্তী if এক্সপ্রেশন x < 0 যাচাই করবে।
• যদি x < 0 হয়, তাহলে "Negative" রিটার্ন হবে, অন্যথায় "Zero" রিটার্ন হবে।

উদাহরণ ৪: if, then, else স্টেটমেন্টের সাথে ফাংশন কম্পোজিশন

Haskell এ ফাংশন কম্পোজিশন খুবই সাধারণ, এবং if, then, else এক্সপ্রেশনগুলো সরাসরি অন্য ফাংশনের সাথে ব্যবহার করা যায়।

describeTemperature :: Float -> String
describeTemperature temp = if temp < 0
                           then "Freezing"
                           else if temp < 15
                                then "Cold"
                                else if temp < 25
                                     then "Warm"
                                     else "Hot"

এখানে:

• temp < 0 হলে "Freezing" রিটার্ন হবে।
• temp < 15 হলে "Cold" রিটার্ন হবে।
• temp < 25 হলে "Warm" রিটার্ন হবে।
• অন্যথায় "Hot" রিটার্ন হবে।

উদাহরণ ৫: if, then, else স্টেটমেন্ট মেইন ফাংশনের সাথে ব্যবহার

নিচে একটি উদাহরণ দেওয়া হলো যেখানে if, then, else স্টেটমেন্ট ব্যবহার করে একটি পূর্ণসংখ্যার মান নির্ধারণ করা হয়েছে।

main :: IO ()
main = do
    let x = 5
    putStrLn (if x > 10 then "Greater than 10" else "10 or less")

এখানে:

• x > 10 যদি True হয়, তাহলে "Greater than 10" প্রিন্ট হবে।
• অন্যথায়, "10 or less" প্রিন্ট হবে।

সংক্ষিপ্ত সারাংশ

Haskell এ if, then, এবং else স্টেটমেন্ট শর্ত ভিত্তিক সিদ্ধান্ত গ্রহণের জন্য ব্যবহৃত হয়। যেহেতু Haskell একটি ফাংশনাল ভাষা, প্রতিটি if এক্সপ্রেশনের জন্য then এবং else অংশ থাকা বাধ্যতামূলক। এটি কোডের নির্ভুলতা এবং স্থিতিশীলতা নিশ্চিত করে এবং প্রোগ্রামারকে নির্ধারিত আউটপুট প্রদান করতে বাধ্য করে, যা প্রোগ্রামিং সহজ করে তোলে।

Haskell এ Pattern Matching এর মাধ্যমে Decision Making

Pattern Matching Haskell এর একটি অত্যন্ত শক্তিশালী বৈশিষ্ট্য, যা সিদ্ধান্ত গ্রহণ (Decision Making) এবং ডেটা স্ট্রাকচারগুলির সাথে কাজ করার সময় কোডকে আরও পরিষ্কার, সংক্ষিপ্ত এবং কার্যকরী করে তোলে। Pattern Matching ব্যবহার করে আপনি ডেটার আকার, ধরণ বা মানের উপর ভিত্তি করে সিদ্ধান্ত নিতে পারেন।

Haskell এ, pattern matching ব্যবহার করে একাধিক কেস বা শর্তের জন্য সহজে সিদ্ধান্ত নেওয়া যায়। এটি মূলত লিস্ট, টিউপলস, ডেটা টাইপ বা অন্যান্য ডেটা স্ট্রাকচার এর মান বা আকারের সাথে তুলনা করে কাজ করে।

১. Pattern Matching ব্যবহার করে Decision Making

Pattern Matching এর মাধ্যমে কোডের বিভিন্ন শর্তে সিদ্ধান্ত নেওয়া খুবই সহজ এবং পরিষ্কার। উদাহরণস্বরূপ, আপনি if-else বা case স্টেটমেন্টের পরিবর্তে pattern matching ব্যবহার করতে পারেন।

উদাহরণ ১: লিস্টের প্রথম উপাদান চেক করা

isEmpty :: [a] -> Bool
isEmpty [] = True    -- যদি লিস্টটি খালি হয়
isEmpty (_:_) = False  -- যদি লিস্টটি খালি না হয়

এখানে isEmpty ফাংশনটি একটি লিস্ট নেয় এবং তা খালি কিনা চেক করে। pattern matching এর মাধ্যমে এটি দুটি ভিন্ন কেস চেক করছে:

• যদি লিস্টটি খালি হয়, তবে True ফেরত দেয়।
• যদি লিস্টটি খালি না হয়, তবে False ফেরত দেয়।

ব্যবহার:

Prelude> isEmpty []
True

Prelude> isEmpty [1, 2, 3]
False

এখানে [] (খালি লিস্ট) এবং (_:_) (যেখানে _ প্রথম উপাদান এবং xs বাকি উপাদানগুলির প্রতিনিধিত্ব করে) ব্যবহার করা হয়েছে।

২. Pattern Matching ব্যবহার করে বিভিন্ন কেস চেক করা

Haskell এ আপনি case স্টেটমেন্টের মাধ্যমে বিভিন্ন শর্ত চেক করতে পারেন, কিন্তু pattern matching এর মাধ্যমে অনেক সহজে সিদ্ধান্ত নেওয়া যায়। উদাহরণ:

উদাহরণ ২: সংখ্যার ধরণের ওপর ভিত্তি করে সিদ্ধান্ত নেওয়া

describeNumber :: Int -> String
describeNumber 0 = "Zero"
describeNumber 1 = "One"
describeNumber 2 = "Two"
describeNumber _ = "Other"  -- _ ব্যবহার করে অন্য সব মানকে ধরছে

এখানে, describeNumber ফাংশনটি একটি সংখ্যা নিয়ে সেটি 0, 1, 2 বা অন্য যেকোনো মান হতে পারে, সেক্ষেত্রে ভিন্ন ভিন্ন ফলাফল দিবে।

ব্যবহার:

Prelude> describeNumber 0
"Zero"

Prelude> describeNumber 1
"One"

Prelude> describeNumber 5
"Other"

এখানে, _ দিয়ে "Other" কেসটি প্রতিস্থাপন করা হয়েছে, যা অন্যান্য সব সংখ্যার জন্য প্রযোজ্য।

৩. Pattern Matching এবং টিউপলস

Pattern Matching শুধু লিস্টের জন্যই নয়, আপনি টিউপল বা ডেটা টাইপ এর ক্ষেত্রেও এটি ব্যবহার করতে পারেন।

উদাহরণ ৩: টিউপল এর মানের ওপর ভিত্তি করে সিদ্ধান্ত নেওয়া

describeTuple :: (Int, Int) -> String
describeTuple (0, 0) = "Origin"
describeTuple (x, 0) = "X-axis"
describeTuple (0, y) = "Y-axis"
describeTuple (x, y) = "Point (" ++ show x ++ ", " ++ show y ++ ")"

এখানে, describeTuple ফাংশনটি একটি টিউপল নেয়, এবং টিউপলটির মানের ওপর ভিত্তি করে বিভিন্ন সিদ্ধান্ত নেয়:

• (0, 0) এর জন্য "Origin"।
• (x, 0) এর জন্য "X-axis"।
• (0, y) এর জন্য "Y-axis"।
• অন্য যেকোনো টিউপল এর জন্য "Point (x, y)"।

ব্যবহার:

Prelude> describeTuple (0, 0)
"Origin"

Prelude> describeTuple (3, 0)
"X-axis"

Prelude> describeTuple (0, 4)
"Y-axis"

Prelude> describeTuple (3, 4)
"Point (3, 4)"

এখানে টিউপল (x, y) এর মান অনুযায়ী বিভিন্ন আউটপুট আসছে।

৪. Pattern Matching এর সাথে Guards

Haskell এ Guards ব্যবহৃত হয় যখন আপনি pattern matching এর সাথে অতিরিক্ত শর্ত যোগ করতে চান। এটি কন্ডিশনাল (শর্তসাপেক্ষ) রুল হিসেবে কাজ করে, যা আপনার কোডকে আরও ফ্লেক্সিবল করে তোলে।

উদাহরণ ৪: Guards সহ Pattern Matching

describeAge :: Int -> String
describeAge age
  | age < 13 = "Child"
  | age < 20 = "Teenager"
  | age < 65 = "Adult"
  | otherwise = "Senior"

এখানে, describeAge ফাংশনটি একটি বয়স নেয় এবং তার ভিত্তিতে এটি "Child", "Teenager", "Adult", বা "Senior" বলে আউটপুট প্রদান করে। Guards ব্যবহার করা হয়েছে যাতে বিভিন্ন শর্তে কাজ করা যায়।

ব্যবহার:

Prelude> describeAge 10
"Child"

Prelude> describeAge 16
"Teenager"

Prelude> describeAge 30
"Adult"

Prelude> describeAge 70
"Senior"

এখানে | দিয়ে শর্তগুলি চেক করা হয়েছে এবং otherwise দিয়ে শেষ শর্তটি ধরা হয়েছে।

উপসংহার

Haskell এ Pattern Matching খুবই শক্তিশালী এবং পরিষ্কারভাবে কোড লেখার জন্য একটি অপরিহার্য টুল। এটি বিশেষভাবে Decision Making এর জন্য ব্যবহৃত হয়, যেখানে আপনি ডেটার আকার বা মানের ওপর ভিত্তি করে বিভিন্ন শর্তে সিদ্ধান্ত নিতে পারেন। Pattern Matching এর মাধ্যমে কোডটি আরও সোজা, সংক্ষিপ্ত এবং দক্ষ হয়ে ওঠে। এটি Guards বা case স্টেটমেন্টের সাথে একত্রিত হলে আরও শক্তিশালী হয়, এবং কোডের জটিলতা কমায়।

Haskell এ Case Expressions এবং Guarded Expressions

Haskell এ case expressions এবং guarded expressions হল দুটি গুরুত্বপূর্ণ কনস্ট্রাক্ট যা কোডে শর্ত নির্ধারণ করার জন্য ব্যবহৃত হয়। এগুলি সাধারণত প্যাটার্ন ম্যাচিং এর সাথে সম্পর্কিত, এবং কোডের পড়তে সহজতা, পরিষ্কারতা, এবং কার্যকারিতা বৃদ্ধি করে।

1. Case Expressions (কেস এক্সপ্রেশন)

Case expressions হল একটি শর্তাধীন গঠন যা একাধিক প্যাটার্নের মধ্যে একটি নির্বাচন করে এবং সেই অনুযায়ী কার্যক্রম চালায়। এটি case কীওয়ার্ড ব্যবহার করে এবং সাধারণত প্যাটার্ন ম্যাচিং এর জন্য ব্যবহৃত হয়।

Case Expression এর সিনট্যাক্স:

case expression of
    pattern1 -> result1
    pattern2 -> result2
    ...
    _        -> defaultResult

এখানে:

• expression: এটি সেই মান যা আমরা যাচাই করতে চাই।
• pattern1, pattern2, ইত্যাদি: এগুলি বিভিন্ন প্যাটার্ন যেগুলির সাথে expression মিলিয়ে দেখা হবে।
• defaultResult: এটি একটি ডিফল্ট মান, যা যদি কোন প্যাটার্নের সাথে মেলে না তবে ফেরত দেওয়া হবে। সাধারণত _ ব্যবহার করা হয়, যা "any value" এর প্রতিনিধিত্ব করে।

Case Expressions এর উদাহরণ:

-- একটি সংখ্যা যাচাই করার ফাংশন
checkNumber :: Int -> String
checkNumber x = case x of
    0 -> "Zero"
    1 -> "One"
    2 -> "Two"
    _ -> "Other"

এখানে, checkNumber ফাংশনটি ইনপুট সংখ্যার উপর ভিত্তি করে একটি স্ট্রিং ফেরত দেয়।

• যদি x 0 হয়, তাহলে "Zero" ফেরত দেয়।
• যদি x 1 হয়, তাহলে "One" ফেরত দেয়।
• যদি x 2 হয়, তাহলে "Two" ফেরত দেয়।
• অন্য যে কোনো মানের জন্য "Other" ফেরত দেয়, যেটি _ দ্বারা প্রতিনিধিত্ব করা হয়, অর্থাৎ ডিফল্ট প্যাটার্ন।

উদাহরণ:

checkNumber 1  -- ফলস্বরূপ: "One"
checkNumber 4  -- ফলস্বরূপ: "Other"

2. Guarded Expressions (গার্ডেড এক্সপ্রেশন)

Guarded expressions হ'ল শর্তের জন্য একটি বিকল্প উপায়, যেখানে শর্তগুলির জন্য | (পাইপ সাইন) ব্যবহার করা হয়। এটি সাধারণত ফাংশনের বিভিন্ন শর্তাধীন শাখাগুলির জন্য ব্যবহৃত হয় এবং গার্ড (শর্ত) ব্যবহার করে প্রতিটি শাখার মান নির্ধারণ করে।

Guarded Expressions এর সিনট্যাক্স:

functionName argument
    | condition1 = result1
    | condition2 = result2
    | otherwise  = defaultResult

এখানে:

• condition1, condition2: এগুলি শর্ত যা যাচাই করা হবে।
• result1, result2: শর্ত পূর্ণ হলে ফলাফল।
• otherwise: এটি একটি ডিফল্ট গার্ড যা সব শর্ত বিফল হলে কার্যকরী হয়। otherwise একটি বিশেষ কিওয়ার্ড যা True সমান।

Guarded Expressions এর উদাহরণ:

-- একটি সংখ্যা যাচাই করার গার্ডেড ফাংশন
checkNumberGuarded :: Int -> String
checkNumberGuarded x
    | x == 0    = "Zero"
    | x == 1    = "One"
    | x == 2    = "Two"
    | otherwise = "Other"

এখানে, checkNumberGuarded ফাংশনটি x এর মানের উপর ভিত্তি করে স্ট্রিং ফেরত দেয়।

• প্রথমে চেক করা হয়, যদি x 0 হয় তবে "Zero" ফেরত দেয়।
• এরপর, যদি x 1 হয়, তবে "One" ফেরত দেয়।
• যদি x 2 হয়, "Two" ফেরত দেয়।
• অন্য যে কোনো মানের জন্য "Other" ফেরত দেয়, যা otherwise দ্বারা চিহ্নিত।

উদাহরণ:

checkNumberGuarded 1  -- ফলস্বরূপ: "One"
checkNumberGuarded 4  -- ফলস্বরূপ: "Other"

3. Case Expressions এবং Guarded Expressions এর মধ্যে পার্থক্য

উপসংহার

Case expressions এবং Guarded expressions হল Haskell এ শর্ত নির্ধারণের জন্য দুটি শক্তিশালী কৌশল। Case expressions সাধারণত প্যাটার্ন ম্যাচিং ব্যবহারের জন্য উপযুক্ত, যেখানে Guarded expressions শর্তগুলো আরও পরিষ্কারভাবে উল্লেখ করতে সহায়ক। কোনটি ব্যবহার করা হবে তা নির্ভর করে কোডের কাঠামো এবং ব্যবহারকারী পছন্দের উপর, তবে উভয় ক্ষেত্রেই কোডের পাঠযোগ্যতা এবং কার্যকারিতা বাড়ানো সম্ভব।

Haskell এ Looping এর পরিবর্তে Recursion এর ব্যবহার

Haskell একটি ফাংশনাল প্রোগ্রামিং ভাষা, যেখানে recursion (পুনরাবৃত্তি) সাধারণত looping (লুপিং) এর পরিবর্তে ব্যবহৃত হয়। হ্যাসকেল এবং অন্যান্য ফাংশনাল ভাষায়, ফাংশনগুলির পুনরাবৃত্তি ব্যবহারের মাধ্যমে সমস্যার সমাধান করা হয়, কারণ ফাংশনাল প্রোগ্রামিংয়ে স্টেট এবং মিউটেবল ভেরিয়েবল ব্যবহার না করার প্রচলন রয়েছে।

এখানে লুপের পরিবর্তে recursion ব্যবহারের মূল কারণ হলো, ফাংশনাল ভাষাগুলিতে মিউটেশন (state mutation) এবং লুপ কন্ট্রোল স্টেটমেন্ট যেমন for, while বা do-while নেই, সেজন্য প্রোগ্রামগুলির কার্যকলাপ এবং পুনরাবৃত্তি ফাংশনালভাবে পরিচালিত হয়।

1. Recursion কি?

Recursion হলো একটি পদ্ধতি যেখানে একটি ফাংশন নিজেকে কল করে নির্দিষ্ট শর্তে বা স্টেট পর্যন্ত পৌঁছানোর জন্য। এটি এমন একটি কৌশল যা একাধিক পর্যায়ে একটি সমস্যা সমাধান করতে পারে এবং এটি পুনরাবৃত্তির মাধ্যমে কাজ করে।

Recursion এর মৌলিক উপাদান:

• Base case: একটি নির্দিষ্ট শর্ত যা রিকার্সন বন্ধ করে দেয় (যেমন, কোনো মান পৌঁছালে প্রোগ্রাম আরও এগোবে না)।
• Recursive case: একটি শর্ত যেখানে ফাংশন নিজেকে কল করে পুনরায় কাজ শুরু করে।

2. Looping এর পরিবর্তে Recursion

2.1. Factorial (ফ্যাক্টরিয়াল) এর উদাহরণ

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

Looping (Imperative Style)

factorialLoop :: Integer -> Integer
factorialLoop n = product [1..n]

Recursion (Functional Style)

factorial :: Integer -> Integer
factorial 0 = 1  -- Base case: 0! = 1
factorial n = n * factorial (n - 1)  -- Recursive case

এখানে, factorial ফাংশনটি নিজেকে কল করছে যতক্ষণ না n শূন্য না হয়ে যায়। এটি base case (যেখানে n = 0) পর্যন্ত অপেক্ষা করে, তারপর সেই মান ফেরত দেয়।

ব্যাখ্যা:

• Base case: factorial 0 = 1 (যেখানে গাণিতিকভাবে 0! = 1)
• Recursive case: factorial n = n * factorial (n - 1) (যেখানে n > 0)

2.2. Sum of a List (তালিকার যোগফল)

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

Looping (Imperative Style)

sumList :: [Integer] -> Integer
sumList xs = sum xs

Recursion (Functional Style)

sumList :: [Integer] -> Integer
sumList [] = 0  -- Base case: Empty list returns 0
sumList (x:xs) = x + sumList xs  -- Recursive case: Add head to the sum of tail

ব্যাখ্যা:

• Base case: sumList [] = 0 (খালি তালিকা হলে যোগফল 0)
• Recursive case: sumList (x:xs) = x + sumList xs (প্রথম উপাদানটি যোগফলে যোগ করে বাকি তালিকার জন্য ফাংশনটি আবার কল করা হয়)

2.3. Fibonacci Sequence (ফিবোনাচ্চি সংখ্যা)

ফিবোনাচ্চি সিরিজে প্রতিটি সংখ্যা আগের দুটি সংখ্যার যোগফল হয়। এটি লুপিংয়ের পরিবর্তে recursion ব্যবহার করে সহজে সমাধান করা যায়।

Looping (Imperative Style)

fibonacciLoop :: Integer -> Integer
fibonacciLoop n = if n <= 1 then n else fibonacciLoop (n - 1) + fibonacciLoop (n - 2)

Recursion (Functional Style)

fibonacci :: Integer -> Integer
fibonacci 0 = 0  -- Base case: Fibonacci(0) = 0
fibonacci 1 = 1  -- Base case: Fibonacci(1) = 1
fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)  -- Recursive case

ব্যাখ্যা:

• Base case: fibonacci 0 = 0, fibonacci 1 = 1 (যেখানে F(0) = 0 এবং F(1) = 1)
• Recursive case: fibonacci n = fibonacci (n - 1) + fibonacci (n - 2) (যেখানে n > 1)

2.4. Tail Recursion

কিছু পরিস্থিতিতে, tail recursion ব্যবহৃত হয়। এটি একটি বিশেষ ধরনের recursion যেখানে পুনরাবৃত্তির শেষে কোনো অতিরিক্ত কাজ করা হয় না, অর্থাৎ পুনরাবৃত্তি শেষ হওয়ার পর কোনো হিসাব বা অপারেশন থাকে না। Tail recursion অধিক কার্যকরী, কারণ এটি stack overflow সমস্যার হাত থেকে রক্ষা করতে পারে এবং অধিক কার্যকরভাবে মেমরি ব্যবহার করতে সাহায্য করে।

Tail Recursion উদাহরণ:

factorialTail :: Integer -> Integer -> Integer
factorialTail 0 acc = acc  -- Base case: return accumulated value
factorialTail n acc = factorialTail (n - 1) (n * acc)  -- Tail recursive case

এখানে, acc (accumulator) ব্যবহার করা হয়েছে, যা ফাংশনের মধ্যে মান জমা রাখে এবং পুনরাবৃত্তি শেষে ফলাফল হিসেবে প্রদান করা হয়।

2.5. Looping এবং Recursion এর তুলনা

উপসংহার

Haskell এ recursion হল লুপের পরিবর্তে ব্যবহৃত একটি গুরুত্বপূর্ণ কৌশল যা ফাংশনাল প্রোগ্রামিংয়ের মূলভিত্তি। Recursion কোডকে কমপ্যাক্ট এবং পরিষ্কার রাখে এবং এর মাধ্যমে যেকোনো পুনরাবৃত্তির সমস্যাকে সহজে সমাধান করা যায়। Tail recursion ব্যবহার করে প্রোগ্রাম আরও দক্ষ এবং মেমরি সাশ্রয়ী করা যেতে পারে, যা looping এর তুলনায় আরও কার্যকরী হতে পারে, বিশেষত বড় ডেটা সেট এবং জটিল কেসে।