Macro Rules এবং Macro Expansion

Rust-এ macros কোডের পুনঃব্যবহারযোগ্যতা এবং শর্তসাপেক্ষ কার্যকারিতা উন্নত করতে ব্যবহৃত হয়। Macro rules Rust এর এমন একটি শক্তিশালী বৈশিষ্ট্য যা ডাইনামিকভাবে কোড জেনারেট করার জন্য ব্যবহৃত হয়। এটি functions এর মতো কিন্তু তাদের স্ট্যাটিক টাইপিং বা রিটার্ন টাইপের সীমাবদ্ধতা ছাড়াই কাজ করে। ম্যাক্রো একটি pattern-matching সিস্টেম ব্যবহার করে ইনপুট কোডের ধরন অনুযায়ী আউটপুট কোড তৈরি করতে পারে।

Rust-এ দুটি প্রধান ধরনের ম্যাক্রো রয়েছে:

1. Declarative Macros (যেখানে macro_rules! ব্যবহার করা হয়)
2. Procedural Macros (যেগুলি অধিক অ্যাডভান্সড ফিচার যেমন derive, attribute ইত্যাদি পেতে ব্যবহার করা হয়)

এখানে আমরা Declarative Macros এবং macro_rules! সম্পর্কে আলোচনা করব, যেটি Rust-এ সবচেয়ে সাধারণ ম্যাক্রো প্রকার।

macro_rules! দিয়ে Macro Rules ডিফাইন করা

Rust-এ macros সাধারণত macro_rules! কীওয়ার্ড দিয়ে ডিফাইন করা হয়। এটি একটি প্যাটার্ন-ম্যাচিং সিস্টেম ব্যবহার করে, যেখানে আপনি নির্দিষ্ট ইনপুট এবং আউটপুট প্যাটার্ন নির্ধারণ করেন।

উদাহরণ: সাধারণ ম্যাক্রো ডিফাইন করা

macro_rules! say_hello {
    () => {
        println!("Hello, world!");
    };
}

fn main() {
    say_hello!();  // ম্যাক্রো কল
}

এখানে say_hello!() একটি ম্যাক্রো যা কোনো আর্গুমেন্ট ছাড়াই "Hello, world!" আউটপুট করে। macro_rules! দিয়ে ম্যাক্রো ডিফাইন করার সময় প্যাটার্ন ম্যাচিং এর মাধ্যমে ইনপুট এবং আউটপুট নির্ধারণ করা হয়।

উদাহরণ: আর্গুমেন্ট সহ ম্যাক্রো

macro_rules! add_two {
    ( $x:expr ) => {
        $x + 2
    };
}

fn main() {
    let result = add_two!(5);  // 5 + 2 = 7
    println!("Result: {}", result);
}

এখানে, add_two! ম্যাক্রো একটি এক্সপ্রেশন গ্রহণ করে এবং সেই এক্সপ্রেশনটির সাথে ২ যোগ করে আউটপুট প্রদান করে। expr হল একটি প্যাটার্ন যা এক্সপ্রেশনকে মেনে চলে।

উদাহরণ: বিভিন্ন প্যাটার্নের জন্য ম্যাক্রো

macro_rules! calculate {
    ( $x:expr, $y:expr ) => {
        $x * $y
    };
    ( $x:expr, $y:expr, $z:expr ) => {
        $x + $y + $z
    };
}

fn main() {
    let result1 = calculate!(5, 3);          // 5 * 3 = 15
    let result2 = calculate!(1, 2, 3);       // 1 + 2 + 3 = 6
    println!("Result1: {}", result1);
    println!("Result2: {}", result2);
}

এখানে, calculate! ম্যাক্রো দুটি ভিন্ন প্যাটার্নের জন্য আলাদা কোড আউটপুট তৈরি করে: একটি দুইটি আর্গুমেন্টের জন্য এবং অন্যটি তিনটি আর্গুমেন্টের জন্য।

Macro Expansion কী?

Macro Expansion হল Rust এর একটি প্রক্রিয়া যার মাধ্যমে ম্যাক্রো রুলগুলি রানটাইম-এর আগে কম্পাইল টাইমে প্রসেস হয় এবং প্রযোজ্য কোড জেনারেট করে। ম্যাক্রো এক্সপানশন ঠিক একইভাবে কাজ করে যেমন একটি সাধারণ ফাংশন কল, তবে এর প্রক্রিয়া হচ্ছে কোডের আউটপুট তৈরির মাধ্যমে সরাসরি ইনপুট কনসিডার করা।

Rust কম্পাইলার যখন একটি ম্যাক্রো দেখা পায়, তখন সেটি ম্যাক্রোর প্যাটার্নে মেলে এবং সেই অনুযায়ী ইনপুটের জন্য কোড এক্সপ্যান্ড করে, অর্থাৎ ম্যাক্রো সেই স্থানে কনক্রিট কোড ইনজেক্ট করে।

ম্যাক্রো এক্সপানশন এর উদাহরণ

macro_rules! greet {
    () => {
        println!("Hello, world!");
    };
}

fn main() {
    greet!(); // ম্যাক্রো এক্সপানশন: println!("Hello, world!"); এখানে এক্সপ্যান্ড হবে
}

এখানে greet!() ম্যাক্রো এক্সপ্যান্ড হলে এটি println!("Hello, world!"); আউটপুটে রূপান্তরিত হবে। কম্পাইলার এটি এক্সপ্যান্ড করে এবং কোড রান করবে।

Debugging ম্যাক্রো এক্সপানশন

Rust আপনাকে ম্যাক্রো এক্সপানশন দেখানোর জন্য একটি কমান্ড প্রদান করে, যাতে আপনি দেখতে পারেন যে আপনার ম্যাক্রো কীভাবে এক্সপ্যান্ড হচ্ছে:

cargo expand

এই কমান্ডটি ম্যাক্রো এক্সপানশন দেখানোর জন্য ব্যবহার করা হয় এবং এটি ম্যাক্রো কীভাবে প্রসেস হচ্ছে এবং কিভাবে ইনপুটের মাধ্যমে আউটপুট তৈরি হচ্ছে তা স্পষ্ট করে।

Macro Expansion এবং Code Generation

ম্যাক্রো এক্সপানশন এক ধরনের code generation যেখানে স্ট্যাটিকভাবে ম্যাক্রো ডিফাইন করা হয় এবং কম্পাইল টাইমে তা এক্সপ্যান্ড হয়ে জেনারেটেড কোড তৈরি করে। এটি প্রোগ্রামিংয়ে পুনঃব্যবহারযোগ্যতা এবং কোডের লাইন সংখ্যা কমানোর জন্য খুবই কার্যকরী।

উদাহরণ: Code Generation এর মাধ্যমে কমপ্লেক্স কাজ করা

macro_rules! create_point {
    ( $x:expr, $y:expr ) => {
        struct Point {
            x: i32,
            y: i32,
        }

        let point = Point { x: $x, y: $y };
        println!("Point: ({}, {})", point.x, point.y);
    };
}

fn main() {
    create_point!(10, 20);
}

এখানে create_point! ম্যাক্রোটি দুটি আর্গুমেন্ট নেয় এবং একটি Point স্ট্রাকচার তৈরি করে যা আউটপুটে একটি পয়েন্টের কন্ডিশন প্রিন্ট করে। ম্যাক্রো এক্সপানশন এখানে কোড জেনারেট করে যা মূল ফাংশনের বাইরে।

সারাংশ

Rust-এ macros কোড জেনারেশন এবং পুনঃব্যবহারযোগ্যতা উন্নত করতে ব্যবহৃত হয়। macro_rules! ব্যবহার করে declarative macros তৈরি করা হয় এবং এগুলি macro expansion প্রক্রিয়ায় এক্সপ্যান্ড হয়ে কোড তৈরি করে। ম্যাক্রো সিস্টেম আপনাকে স্ট্যাটিক কোড জেনারেশন করার মাধ্যমে কার্যকরীভাবে কোডের পুনঃব্যবহার নিশ্চিত করতে সাহায্য করে। Rust-এ ম্যাক্রো রুল এবং এক্সপানশন ব্যবহারের মাধ্যমে বড় প্রোজেক্টগুলোর মধ্যে কার্যকরী কোড ম্যানিপুলেশন সম্ভব।