প্যারামিটার পাসিং মেকানিজম

১ · অ্যাক্টিভেশন রেকর্ডের প্যারামিটার স্লট — কীভাবে ভরা হয়

M11/L48-এ দেখা গেছে, প্রতিটি অ্যাক্টিভেশন রেকর্ডে একটি প্যারামিটার স্লট থাকে। কিন্তু ঠিক কীভাবে caller-এর আর্গুমেন্ট মান সেই স্লটে "ভরা" হয় — সেই ভিন্ন-ভিন্ন কৌশলগুলোই এই পাঠের বিষয়। ভাষাভেদে এই কৌশল ভিন্ন, এবং এই পার্থক্যের সরাসরি, বাস্তব প্রভাব আছে callee কী করতে পারবে তার উপর।

২ · Pass-by-value — কপি ও আইসোলেশন

Pass-by-valuePass-by-valueCallee আর্গুমেন্টের মানের একটি কপি পায় — callee-এর পরিবর্তন caller-এর অরিজিনালকে প্রভাবিত করে না। -এ callee আর্গুমেন্টের মানের একটি কপি পায় — callee নিজের কপিতে যা-ই পরিবর্তন করুক না কেন, caller-এর অরিজিনাল ভ্যারিয়েবল অপরিবর্তিত থাকে। এটি একটি গুরুত্বপূর্ণ আইসোলেশন গ্যারান্টি: একটি ফাংশন কল করার পরও caller নিশ্চিত থাকতে পারে তার নিজের ডেটা অক্ষত আছে (যদি না ফাংশনটি স্পষ্টভাবে একটি নতুন মান রিটার্ন করে caller নিজেই সেটি assign করে)।

৩ · Pass-by-reference — সরাসরি একই স্টোরেজে অ্যাক্সেস

Pass-by-referencePass-by-referenceCallee caller-এর অরিজিনাল ভ্যারিয়েবলের একটি রেফারেন্স/alias পায় — একই আন্ডারলাইং স্টোরেজে কাজ করে। -এ callee caller-এর অরিজিনাল ভ্যারিয়েবলের একটি রেফারেন্স (কার্যত একটি alias) পায় — callee যা পরিবর্তন করে তা সরাসরি caller-এর অরিজিনালেও প্রতিফলিত হয়, কারণ উভয়েই একই আন্ডারলাইং স্টোরেজে কাজ করছে, কপিতে নয়। এটি একটি সত্যিকারের ভিন্ন, বেশি permissive সিমান্টিক্স — একটি ফাংশন ইচ্ছাকৃতভাবে (ভালো বা মন্দ, উভয় অর্থেই) তার caller-এর ভ্যারিয়েবল বদলে দিতে পারে এই মেকানিজমের মাধ্যমে।

৪ · Pass-by-name — ঐতিহাসিক, বিরল, বিস্ময়কর

Pass-by-namePass-by-nameআর্গুমেন্ট এক্সপ্রেশনটি নিজেই (তার ইভালুয়েটেড মান নয়) পাস হয়, এবং callee-এর ভেতরে প্রতিবার ব্যবহারের সময় নতুন করে ইভালুয়েট হয়। একটি ঐতিহাসিকভাবে গুরুত্বপূর্ণ কিন্তু এখন বিরল মেকানিজম — এখানে আর্গুমেন্ট এক্সপ্রেশনটি নিজেই (তার ইভালুয়েটেড মান নয়, এবং একটি সাধারণ রেফারেন্সও নয়) পাস হয়, এবং callee-এর ভেতরে প্যারামিটারটি যতবার ব্যবহৃত হয় ততবারই সেই এক্সপ্রেশন নতুন করে ইভালুয়েট হয়। এর বাস্তব, বিস্ময়কর ফলাফল: যদি আর্গুমেন্ট এক্সপ্রেশনে সাইড-ইফেক্ট থাকে, বা এমন একটি ভ্যারিয়েবল রেফার করে যা callee চলাকালীন বদলে যায়, তাহলে প্রতিটি ব্যবহার ভিন্ন ভিন্ন ফলাফল দিতে পারে — এটাই মূল কারণ কেন আধুনিক বেশিরভাগ ভাষা এই মেকানিজম এড়িয়ে চলে।

৫ · কোড: by-value বনাম by-reference যাচাই

Python-এর নিজস্ব ডিফল্ট আচরণ আসলে অবজেক্ট-রেফারেন্স পাস করা — তাই সত্যিকারের pass-by-value দেখানোর জন্য নিচের কোডে স্পষ্টভাবে copy.deepcopy দিয়ে কপি তৈরি করা হয়েছে। এরপর একই modifier_fn ও একই স্টার্টিং লিস্ট দিয়ে দুটো মেকানিজম চালিয়ে caller-এর লিস্টের অবস্থা যাচাই করা হয়েছে।

import copy


def call_by_value(original_list, modifier_fn):
    """callee একটি deep copy-তে কাজ করে -- caller-এর original অস্পৃশ্য থাকে।"""
    local_copy = copy.deepcopy(original_list)
    modifier_fn(local_copy)
    return original_list, local_copy


def call_by_reference(original_list, modifier_fn):
    """callee সরাসরি caller-এর original object-এ কাজ করে।"""
    modifier_fn(original_list)
    return original_list


def append_99(lst):
    lst.append(99)


# --- Pass-by-value ---
caller_list_a = [1, 2, 3]
print(f"call_by_value-এর আগে caller_list_a = {caller_list_a}")
original_a, copy_a = call_by_value(caller_list_a, append_99)
print(f"call_by_value-এর পরে caller_list_a = {caller_list_a}   (অপরিবর্তিত থাকা উচিত)")
print(f"callee-এর ভেতরের কপি ছিল          = {copy_a}   (এখানেই পরিবর্তন ঘটেছে)")
assert caller_list_a == [1, 2, 3]
assert copy_a == [1, 2, 3, 99]

# --- Pass-by-reference ---
caller_list_b = [1, 2, 3]
print(f"\ncall_by_reference-এর আগে caller_list_b = {caller_list_b}")
call_by_reference(caller_list_b, append_99)
print(f"call_by_reference-এর পরে caller_list_b = {caller_list_b}   (পরিবর্তিত হওয়া উচিত)")
assert caller_list_b == [1, 2, 3, 99]

print("\nসারাংশ:")
print(f"  by-value    -> caller অপরিবর্তিত: {caller_list_a == [1, 2, 3]}")
print(f"  by-reference -> caller পরিবর্তিত : {caller_list_b == [1, 2, 3, 99]}")