Functions এবং Recursion এর ব্যবহার

Erlang-এ Functions এবং Recursion এর ব্যবহার

Erlang একটি ফাংশনাল প্রোগ্রামিং ভাষা, যেখানে functions (ফাংশন) এবং recursion (রিকার্সন) ব্যবহৃত হয়। Erlang-এ ফাংশন খুবই গুরুত্বপূর্ণ এবং এটি প্রোগ্রামিংয়ের মূল অঙ্গ। রিকার্সন Erlang-এ একটি মৌলিক কৌশল, যা পুনরাবৃত্তি (iteration) বা পুনরায় একটি ফাংশন নিজেকে কল করার মাধ্যমে কোনো কাজ সম্পন্ন করার জন্য ব্যবহৃত হয়। এখানে functions এবং recursion এর ব্যবহার সম্পর্কে বিস্তারিত আলোচনা করা হলো।

1. Functions (ফাংশন)

Erlang একটি pure functional programming language, যার মানে এখানে functions ব্যবহার করে প্রোগ্রাম লেখা হয়। Erlang-এ প্রতিটি কার্যক্রম একটি ফাংশনের মধ্যে থাকে এবং ফাংশনগুলিতে pattern matching ও guards ব্যবহার করা যায়।

ফাংশন ডিফিনিশন:

Erlang-এ ফাংশন একটি মডিউলে ডিফাইন করা হয়। প্রতিটি ফাংশন সাধারণত একটি head এবং body নিয়ে গঠিত, যেখানে head হল ফাংশনের নাম এবং প্যারামিটার, আর body হল ফাংশনের কার্যকারিতা।

উদাহরণ:

-module(math).
-export([add/2, multiply/2]).

add(X, Y) ->
    X + Y.

multiply(X, Y) ->
    X * Y.

এখানে, add/2 এবং multiply/2 দুটি ফাংশন রয়েছে যা দুটি সংখ্যার যোগফল এবং গুণফল প্রদান করবে। ফাংশনগুলির সিগনেচার হচ্ছে add/2 এবং multiply/2, যার মানে হলো প্রতিটি ফাংশন দুটি প্যারামিটার নেবে।

2. Function Clauses and Pattern Matching (ফাংশন ক্লজ এবং প্যাটার্ন মাচিং)

Erlang-এ ফাংশন একাধিক ক্লজ বা শর্ত নিয়ে কাজ করতে পারে। Pattern matching এর মাধ্যমে ফাংশন সঠিকভাবে কল করা হয় এবং কার্যকরী ফলাফল পাওয়া যায়। একাধিক ক্লজ ব্যবহার করার মাধ্যমে আমরা বিভিন্ন ইনপুট অনুযায়ী আলাদা কাজ করতে পারি।

উদাহরণ:

-module(calculator).
-export([compute/1]).

compute({add, X, Y}) ->
    X + Y;
compute({subtract, X, Y}) ->
    X - Y;
compute({multiply, X, Y}) ->
    X * Y;
compute({divide, X, Y}) when Y /= 0 ->
    X / Y;
compute({divide, _, 0}) ->
    {error, "Division by zero!"}.

এখানে, compute/1 ফাংশনটি একাধিক ক্লজ নিয়ে কাজ করছে, যেখানে প্রতিটি ক্লজ এক একটি নির্দিষ্ট অপারেশন সম্পাদন করে (যেমন যোগফল, বিয়োগফল, গুণফল, ভাগফল)। এর মধ্যে একটি when গার্ডও ব্যবহার করা হয়েছে, যা divide অপারেশনটি কেবল তখনই কার্যকর করবে যখন বিভাজক শূন্য হবে না।

3. Recursion (রিকার্সন)

Erlang-এ recursion ব্যবহৃত হয় যখন কোনো কাজ সম্পাদন করতে একটি ফাংশন নিজেকে পুনরায় কল করে। এটি মূলত iteration বা পুনরাবৃত্তি কাজের জন্য ব্যবহৃত হয়, কারণ Erlang-এ loops নেই (যেমন সি বা জাভাতে)। রিকার্সন অত্যন্ত গুরুত্বপূর্ণ এবং প্রায়শই ব্যবহৃত একটি কৌশল।

উদাহরণ ১: লিস্টের যোগফল

-module(recursion_example).
-export([sum/1]).

sum([Head | Tail]) ->
    Head + sum(Tail);
sum([]) -> 
    0.

এখানে, sum/1 ফাংশনটি একটি লিস্টের উপাদানগুলো যোগ করার জন্য রিকার্সন ব্যবহার করছে:

• প্রথম ক্লজটি লিস্টের প্রথম উপাদান (Head) এবং বাকি উপাদানগুলো (Tail) একসাথে যোগ করে পুনরায় sum/1 ফাংশনকে কল করছে।
• দ্বিতীয় ক্লজটি বেস কেস, যেখানে খালি লিস্ট পেলে যোগফল হবে 0।

উদাহরণ ২: ফ্যাক্টোরিয়াল হিসাব করা

-module(factorial).
-export([calculate/1]).

calculate(0) -> 1;
calculate(N) when N > 0 -> N * calculate(N - 1).

এখানে, calculate/1 ফাংশনটি রিকার্সন ব্যবহার করে একটি পূর্ণসংখ্যার ফ্যাক্টোরিয়াল বের করার জন্য ব্যবহৃত হয়েছে:

• প্রথম ক্লজটি 0 এর জন্য ফ্যাক্টোরিয়াল 1 রিটার্ন করবে।
• দ্বিতীয় ক্লজটি N এর মান বড় হলে নিজেকে N-1 দিয়ে কল করবে।

4. Tail Recursion (টেইল রিকার্সন)

Erlang-এ tail recursion এমন একটি রিকার্সন কৌশল, যেখানে রিকার্সন কলটি ফাংশনের শেষে থাকে। এটি আরো দক্ষ এবং stack overflow থেকে রক্ষা পায়, কারণ Erlang এর garbage collector রিকার্সন কলের শেষে হিসাব করে মেমরি ব্যবহারের ওপর নজর রাখে।

উদাহরণ:

-module(tail_recursion).
-export([factorial/1]).

factorial(N) -> factorial(N, 1).

factorial(0, Acc) -> Acc;
factorial(N, Acc) when N > 0 -> factorial(N - 1, N * Acc).

এখানে, factorial/1 ফাংশনটি factorial/2 নামক একটি সহায়ক ফাংশন ব্যবহার করে এবং টেইল রিকার্সন ব্যবহৃত হয়েছে:

• প্রথম ক্লজটি Acc (অ্যাকিউমুলেটর) এর মান রিটার্ন করে, যা ফ্যাক্টোরিয়াল হিসাবের জন্য ব্যবহৃত হয়।
• দ্বিতীয় ক্লজটি N এর মান কমাতে এবং Acc আপডেট করতে factorial/2 ফাংশনটি পুনরায় কল করে।

5. Higher-Order Functions (হায়ার-অর্ডার ফাংশন)

Erlang-এ higher-order functions ব্যবহৃত হয়, যেখানে একটি ফাংশন অন্য একটি ফাংশনকে আর্গুমেন্ট হিসেবে গ্রহণ করতে পারে বা একটি ফাংশন রিটার্ন করতে পারে।

উদাহরণ:

-module(higher_order).
-export([map/2, square/1]).

map([], _) -> [];
map([Head | Tail], Fun) -> [Fun(Head) | map(Tail, Fun)].

square(X) -> X * X.

এখানে, map/2 একটি হায়ার-অর্ডার ফাংশন যা একটি ফাংশন (Fun) গ্রহণ করে এবং একটি লিস্টের উপর সেই ফাংশন প্রয়োগ করে। square/1 ফাংশনটি একটি সংখ্যা যেকোনো সংখ্যার বর্গফল দেয়।

উপসংহার

Erlang-এ functions এবং recursion দুটি অত্যন্ত গুরুত্বপূর্ণ কৌশল যা কোডের কার্যকারিতা এবং স্কেলেবিলিটি নিশ্চিত করে। Functions ফাংশনাল প্রোগ্রামিংয়ের মাধ্যে কোডের পুনঃব্যবহারযোগ্যতা এবং পরিষ্কারতা বাড়ায়, আর recursion পুনরাবৃত্তি এবং iteration সম্পর্কিত কাজের জন্য অত্যন্ত কার্যকরী। Erlang-এ রিকার্সন এবং ফাংশনাল ডিজাইন প্যাটার্নগুলি কোডকে আরও সহজ, পরিষ্কার এবং নির্ভরযোগ্য করে তোলে।