Generics এবং Traits (জেনেরিক্স এবং ট্রেইটস)

Generics (জেনেরিক্স)

Generics হল রাস্টের এমন একটি বৈশিষ্ট্য যা আপনাকে একাধিক ডেটা টাইপে কাজ করতে সক্ষম করে, যা টাইপ সিস্টেমে ন্যূনতম পুনরাবৃত্তি নিশ্চিত করে। এটি আপনার কোডকে আরও সাধারণ এবং পুনঃব্যবহারযোগ্য করে তোলে।

Generics এর প্রধান সুবিধা:

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

উদাহরণ:

// একটি ফাংশন যা দুটি যেকোনো টাইপের উপাদান যোগ করে
fn add<T>(a: T, b: T) -> T 
where
    T: std::ops::Add<Output = T>,
{
    a + b
}

fn main() {
    let int_result = add(5, 10);  // integer ডেটা টাইপ ব্যবহার
    let float_result = add(5.5, 10.5);  // floating-point ডেটা টাইপ ব্যবহার

    println!("Integer result: {}", int_result);
    println!("Float result: {}", float_result);
}

এখানে T একটি generic parameter যা ফাংশনের টাইপ নির্ধারণ করে। add ফাংশনটি যেকোনো ধরনের টাইপের মান নিতে পারে (যেমন i32, f64, ইত্যাদি) এবং সেই অনুযায়ী টাইপের গণনা করে।

Structs এবং Enums এ জেনেরিক্স ব্যবহার:

// একটি struct যা জেনেরিক টাইপ ব্যবহার করে
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };

    println!("Integer point: ({}, {})", integer_point.x, integer_point.y);
    println!("Float point: ({}, {})", float_point.x, float_point.y);
}

এখানে Point<T> একটি generic struct যা যেকোনো টাইপের মান ধারণ করতে সক্ষম। এতে T টাইপ নির্ধারণ করা হয় এবং একে ব্যবহার করে x এবং y এর মান সংরক্ষণ করা হয়।

Traits (ট্রেইটস)

Traits হল রাস্টের এমন একটি বৈশিষ্ট্য যা নির্দিষ্ট ফাংশনালিটি বা আচরণ প্রদান করে। এটি অন্যান্য ডেটা টাইপের জন্য চুক্তির মতো কাজ করে, যেখানে আমরা নির্দিষ্ট পদ্ধতিগুলি (methods) ব্যবহার করার সুযোগ পায়। Traits আপনাকে বিভিন্ন টাইপে একে অপরের সাথে সাদৃশ্যপূর্ণ আচরণ নিশ্চিত করতে সাহায্য করে।

Traits এর প্রধান বৈশিষ্ট্য:

• কমপ্লেক্স ইন্টারফেস: ট্রেইটস একটি ডেটা টাইপের জন্য নির্দিষ্ট আচরণ বা ফাংশনালিটি ডিফাইন করতে পারে।
• পুনঃব্যবহারযোগ্যতা: একাধিক টাইপের জন্য একই ট্রেইট প্রয়োগ করা যেতে পারে।
• পলিমরফিজম: বিভিন্ন টাইপের জন্য একই ট্রেইট দিয়ে একাধিক উপায় ব্যবহার করা যেতে পারে।

উদাহরণ:

// একটি ট্রেইট যা কাস্টম আচরণ সংজ্ঞায়িত করে
trait Summary {
    fn summarize(&self) -> String;  // ট্রেইটের একটি মেথড
}

// একটি struct যা ট্রেইট Summary এর আচরণ বাস্তবায়ন করে
struct NewsArticle {
    headline: String,
    content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}: {}", self.headline, self.content)
    }
}

fn main() {
    let article = NewsArticle {
        headline: String::from("Rust is great!"),
        content: String::from("Rust is a systems programming language."),
    };

    println!("Article summary: {}", article.summarize());
}

এখানে, Summary নামক একটি ট্রেইট তৈরি করা হয়েছে, যার মধ্যে একটি মেথড summarize ডিফাইন করা হয়েছে। তারপর NewsArticle struct এর জন্য এই ট্রেইটটি impl (implementation) ব্লক দিয়ে বাস্তবায়ন করা হয়েছে।

Multiple Traits এবং Trait Bounds:

// দুটি ট্রেইট
trait Speak {
    fn speak(&self);
}

trait Run {
    fn run(&self);
}

// একটি struct যা দুটি ট্রেইট বাস্তবায়ন করে
struct Dog;

impl Speak for Dog {
    fn speak(&self) {
        println!("Woof!");
    }
}

impl Run for Dog {
    fn run(&self) {
        println!("The dog is running!");
    }
}

fn main() {
    let dog = Dog;
    dog.speak();
    dog.run();
}

এখানে Dog struct দুটি আলাদা ট্রেইট Speak এবং Run বাস্তবায়ন করেছে। এভাবে একাধিক ট্রেইট একটি struct এ ব্যবহার করা সম্ভব।

Generics এবং Traits এর মধ্যে সম্পর্ক

জেনেরিক্স এবং ট্রেইট একসাথে ব্যবহার করা যেতে পারে। উদাহরণস্বরূপ, একটি ফাংশন যা generic টাইপের জন্য ট্রেইট ব্যবহার করে, যাতে সেই টাইপটি ট্রেইটের ডিফাইন করা মেথডগুলো ব্যবহার করতে পারে।

// একটি ট্রেইট যা কাস্টম আচরণ সংজ্ঞায়িত করে
trait Describe {
    fn describe(&self) -> String;
}

// একটি ফাংশন যা জেনেরিক টাইপের জন্য ট্রেইট ব্যবহার করে
fn print_description<T: Describe>(item: T) {
    println!("Description: {}", item.describe());
}

struct Car;

impl Describe for Car {
    fn describe(&self) -> String {
        String::from("A car is a vehicle.")
    }
}

fn main() {
    let my_car = Car;
    print_description(my_car);  // Car struct এর জন্য Describe ট্রেইট ব্যবহার
}

এখানে, print_description একটি জেনেরিক ফাংশন যা Describe ট্রেইট ব্যবহার করে, এবং T: Describe মানে হল যে T টাইপটি Describe ট্রেইটটি বাস্তবায়ন করবে।

সারাংশ

• Generics (জেনেরিক্স): রাস্টের জেনেরিক্স আপনাকে টাইপ সিস্টেমে একাধিক ডেটা টাইপের জন্য কোড লিখতে সক্ষম করে, যা কোডের পুনঃব্যবহারযোগ্যতা বৃদ্ধি করে।
• Traits (ট্রেইটস): ট্রেইটস ডেটা টাইপের জন্য নির্দিষ্ট আচরণ বা ফাংশনালিটি সংজ্ঞায়িত করতে সাহায্য করে এবং পলিমরফিজম, কোড পুনঃব্যবহারযোগ্যতা এবং টাইপ সেফটি নিশ্চিত করে।

এই দুটি বৈশিষ্ট্য একসাথে ব্যবহৃত হলে কোড আরও শক্তিশালী, স্থিতিশীল এবং নমনীয় হয়ে ওঠে।

Generics এর ধারণা

Generics হল একটি গুরুত্বপূর্ণ প্রোগ্রামিং কৌশল যা প্রোগ্রামকে আরও সাধারণ, পুনঃব্যবহারযোগ্য এবং সুরক্ষিত করতে সহায়ক। Rust এ, Generics এর মাধ্যমে আমরা একটি ফাংশন, স্ট্রাকচার, enum, বা ট্রেট (trait) তৈরি করতে পারি যা বিভিন্ন টাইপের ডেটা নিয়ে কাজ করতে সক্ষম। এতে আমাদের কোডের স্থিতিস্থাপকতা এবং মডুলারিটি বৃদ্ধি পায়, কারণ আমরা একাধিক ডেটা টাইপের সাথে কাজ করতে পারি কোনো টাইপ নির্দিষ্ট না করেই।

Generics ব্যবহারের মাধ্যমে আপনি টাইপের উপর নির্ভর না করে কোড লিখতে পারবেন, এবং কম্পাইল টাইমে টাইপ চেকিংয়ের সুবিধা পাবেন। Rust কম্পাইলার টাইপ চেকিং এর মাধ্যমে টাইপ সেফটি নিশ্চিত করে, যাতে রানটাইমে কোনো সমস্যা না হয়।

Generics এর Syntax (সিনট্যাক্স)

Rust এ, Generics সাধারণত angle brackets (<>) এর মধ্যে টাইপ নাম ব্যবহার করে ডিফাইন করা হয়। এটি ফাংশন, স্ট্রাকচার, enum, অথবা ট্রেটের সাথে যুক্ত হতে পারে।

২.১ Generics with Functions (ফাংশনে Generics)

ফাংশনে জেনেরিক প্যারামিটার ব্যবহার করার জন্য, ফাংশনের নামের পর <> এর মধ্যে টাইপ প্যারামিটার দেয়া হয়।

উদাহরণ:

fn print_value<T>(value: T) {
    println!("The value is: {:?}", value);
}

fn main() {
    print_value(10);         // T is inferred as i32
    print_value("Hello");    // T is inferred as &str
}

এখানে, T একটি Generic Type Parameter। ফাংশনটি যেকোনো ধরনের মান গ্রহণ করতে সক্ষম, এবং T টাইপ প্যারামিটারটি স্বয়ংক্রিয়ভাবে টাইপ ইনফারেন্সের মাধ্যমে চিহ্নিত করা হয়। প্রথম কলের সময় T এর টাইপ হলো i32, আর দ্বিতীয় কলের সময় T এর টাইপ হলো &str।

২.২ Generics with Structs (স্ট্রাকচারেও Generics)

স্ট্রাকচারেও জেনেরিক প্যারামিটার ব্যবহার করা যেতে পারে, যা আমাদের স্ট্রাকচারকে বিভিন্ন ডেটা টাইপের সাথে কাজ করার সক্ষমতা দেয়।

উদাহরণ:

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let int_point = Point { x: 5, y: 10 };        // T is i32
    let float_point = Point { x: 1.0, y: 4.0 };   // T is f64
}

এখানে, Point নামক একটি স্ট্রাকচার তৈরি করা হয়েছে যা জেনেরিক টাইপ T ব্যবহার করছে। এর ফলে একই স্ট্রাকচার i32 বা f64 বা অন্য কোনো টাইপের জন্য ব্যবহার করা সম্ভব।

২.৩ Generics with Enums (এনামেও Generics)

এনাম (enum) এও জেনেরিক টাইপ ব্যবহার করা যায়। এটি বিভিন্ন ডেটা টাইপের জন্য একটি ইউনিফর্ম ডেটা স্ট্রাকচার তৈরি করতে সাহায্য করে।

উদাহরণ:

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {
    let success: Result<i32, &str> = Result::Ok(200);   // T = i32, E = &str
    let error: Result<i32, &str> = Result::Err("Error"); // T = i32, E = &str
}

এখানে, Result একটি জেনেরিক এনাম যা দুটি প্যারামিটার ব্যবহার করে: T (যে টাইপ সফল ফলাফল হবে) এবং E (ত্রুটি টাইপ)। এটি বিভিন্ন ডেটা টাইপের জন্য রিটার্ন ভ্যালু তৈরি করতে সক্ষম।

২.৪ Generics with Traits (ট্রেটেও Generics)

ট্রেটস (traits) ব্যবহারের মাধ্যমে আপনি জেনেরিক টাইপ ব্যবহার করে ফাংশন বা মেথড ডিফাইন করতে পারেন। এর মাধ্যমে আপনি প্রোগ্রামিং কোডের এক্সটেনসিবিলিটি এবং পুনঃব্যবহারযোগ্যতা বৃদ্ধি করতে পারেন।

উদাহরণ:

trait Printable {
    fn print(&self);
}

struct Person {
    name: String,
}

impl Printable for Person {
    fn print(&self) {
        println!("Person name: {}", self.name);
    }
}

fn print_item<T: Printable>(item: T) {
    item.print();
}

fn main() {
    let person = Person { name: String::from("John") };
    print_item(person);
}

এখানে, Printable ট্রেটটি একটি print মেথড ডিফাইন করেছে যা Person স্ট্রাকচারে প্রয়োগ করা হয়েছে। print_item ফাংশনটি যেকোনো টাইপের Printable ট্রেটকে প্রয়োগযোগ্য ভ্যালু নিয়ে কাজ করে।

Constraints (বাধ্যতাসমূহ)

Rust এ, আপনি জেনেরিক টাইপের উপর constraints আরোপ করতে পারেন, অর্থাৎ আপনি নির্দিষ্ট করতে পারেন যে এই টাইপটি কোন ফাংশন বা ট্রেট ব্যবহার করতে পারবে। সাধারণত, এটি T: Trait এর মাধ্যমে করা হয়।

উদাহরণ:

fn print_length<T: ToString>(item: T) {
    println!("Length: {}", item.to_string().len());
}

fn main() {
    print_length(123);       // i32 implements ToString
    print_length("Hello");   // &str implements ToString
}

এখানে, T: ToString বলতে বোঝাচ্ছে যে T টাইপটি ToString ট্রেটের সাথে সম্পর্কিত হতে হবে। এতে শুধুমাত্র সেই টাইপগুলোই এই ফাংশনটি কল করতে পারবে যেগুলো ToString ট্রেট প্রয়োগ করেছে।

সারাংশ

Rust এ Generics একটি অত্যন্ত শক্তিশালী কৌশল, যা আমাদের কোডকে আরো সাধারণ, পুনঃব্যবহারযোগ্য এবং টাইপ সেফ করে তোলে। এর মাধ্যমে ফাংশন, স্ট্রাকচার, এনাম, এবং ট্রেট গুলোকে জেনেরিক টাইপ প্যারামিটার ব্যবহার করে তৈরি করা যায়, যা একাধিক টাইপের সাথে কাজ করতে সক্ষম। Rust এর টাইপ সিস্টেম এবং কম্পাইল টাইম টাইপ চেকিং এই জেনেরিক কোডগুলোকে সুরক্ষিত এবং কার্যকরী করে তোলে।

Traits কী?

রাস্টে Traits একটি শক্তিশালী বৈশিষ্ট্য যা একটি টাইপের আচরণ (behavior) বা ইন্টারফেস সংজ্ঞায়িত করতে ব্যবহৃত হয়। এটি Java বা C# এর ইন্টারফেসের মতো, তবে কিছু পার্থক্যও রয়েছে। Traits একটি বা একাধিক ফাংশন সিগনেচার ধারণ করে, যেগুলি বাস্তবায়ন (implementation) করতে হবে। এটি একটি টাইপের জন্য সাধারণ আচরণ বা গুণাবলী নির্ধারণ করে এবং অন্য টাইপে এই আচরণ প্রয়োগ করার জন্য ব্যবহার করা হয়।

Traits এর মূল উদ্দেশ্য:

• ব্যবহারযোগ্যতা (Reusability): Traits একই আচরণ বা বৈশিষ্ট্য একাধিক টাইপে প্রয়োগ করতে সক্ষম।
• প্রতিক্রিয়া (Polymorphism): Traits এর মাধ্যমে ভিন্ন ধরনের টাইপে একে অপরের মত আচরণ সংজ্ঞায়িত করা সম্ভব।

Traits সংজ্ঞায়িত করা

রাস্টে একটি Trait সংজ্ঞায়িত করতে trait কিওয়ার্ড ব্যবহার করা হয়। Trait এর মধ্যে এক বা একাধিক ফাংশনের সিগনেচার থাকতে পারে, যা একটি নির্দিষ্ট টাইপে বাস্তবায়ন করা প্রয়োজন।

উদাহরণ:

// Trait সংজ্ঞায়িত করা
trait Greet {
    fn greet(&self); // সিগনেচার, যেটি ফাংশনের ভিতরে বাস্তবায়ন করতে হবে
}

// Trait এর বাস্তবায়ন
struct Person {
    name: String,
}

impl Greet for Person {
    fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    
    person.greet(); // "Hello, Alice!"
}

এখানে, Greet একটি Trait যা greet নামক ফাংশন সিগনেচার ধারণ করে। Person struct-এ Greet Trait বাস্তবায়ন করা হয়েছে, যা greet ফাংশনটি প্রিন্ট করবে।

Trait এর সাথে Default Methods

রাস্টে Traits এ default methods বা ডিফল্ট ফাংশনও থাকতে পারে। এর মানে হলো, Trait-এর মধ্যে কিছু ফাংশনের বাস্তবায়ন প্রদান করা যেতে পারে, এবং টাইপগুলো যদি প্রয়োজন মনে না করে তবে তারা এই ডিফল্ট বাস্তবায়ন ব্যবহার করতে পারে।

উদাহরণ:

trait Greet {
    fn greet(&self);
    
    // ডিফল্ট বাস্তবায়ন
    fn farewell(&self) {
        println!("Goodbye!");
    }
}

struct Person {
    name: String,
}

impl Greet for Person {
    fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    let person = Person {
        name: String::from("Bob"),
    };
    
    person.greet();    // "Hello, Bob!"
    person.farewell(); // "Goodbye!"
}

এখানে, farewell ফাংশনটির ডিফল্ট বাস্তবায়ন দেওয়া হয়েছে Trait-এ, এবং Person struct-এ greet বাস্তবায়ন করা হয়েছে, কিন্তু farewell এর ডিফল্ট বাস্তবায়ন ব্যবহার করা হয়েছে।

Traits এবং Polymorphism

রাস্টে Traits ব্যবহার করে polymorphism বা বহুরূপিতা অর্জন করা সম্ভব। এর মানে হলো, একাধিক টাইপ একই Trait ব্যবহার করে এবং একে অপরের মত আচরণ করতে পারে।

উদাহরণ:

trait Describe {
    fn describe(&self) -> String;
}

struct Person {
    name: String,
}

struct Animal {
    species: String,
}

impl Describe for Person {
    fn describe(&self) -> String {
        format!("This is a person named {}", self.name)
    }
}

impl Describe for Animal {
    fn describe(&self) -> String {
        format!("This is an animal of species {}", self.species)
    }
}

fn print_description(item: impl Describe) {
    println!("{}", item.describe());
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };
    
    let animal = Animal {
        species: String::from("Dog"),
    };
    
    print_description(person); // "This is a person named Alice"
    print_description(animal); // "This is an animal of species Dog"
}

এখানে, Describe Trait দুটি ভিন্ন struct (Person এবং Animal) এ বাস্তবায়িত হয়েছে। print_description ফাংশনটি Describe Trait গ্রহণ করে, এবং এটি Person এবং Animal টাইপের জন্য একে অপরের মতো আচরণ করতে সক্ষম।

Trait Bounds

Trait bounds হল এমন নিয়ম যা টাইপের জন্য Trait বাস্তবায়ন নিশ্চিত করে, যাতে সেই টাইপ শুধুমাত্র নির্দিষ্ট Trait ব্যবহার করতে পারে।

উদাহরণ:

// Trait সংজ্ঞায়িত করা
trait Printable {
    fn print(&self);
}

// Trait বাস্তবায়ন
struct Book {
    title: String,
}

impl Printable for Book {
    fn print(&self) {
        println!("Book title: {}", self.title);
    }
}

// একটি ফাংশনে Trait Bound ব্যবহার
fn print_item<T: Printable>(item: T) {
    item.print();
}

fn main() {
    let book = Book {
        title: String::from("Rust Programming"),
    };
    
    print_item(book);
}

এখানে, print_item ফাংশনে T: Printable Trait bound ব্যবহার করা হয়েছে, যা T টাইপের জন্য Printable Trait নিশ্চিত করে।

সারাংশ

• Traits রাস্টে একটি টাইপের আচরণ সংজ্ঞায়িত করতে ব্যবহৃত হয়। Traits সঠিকভাবে ব্যবহার করলে প্রোগ্রামিংয়ে polymorphism, reusability, এবং abstraction সুবিধা পাওয়া যায়।
• Traits এর মাধ্যমে বিভিন্ন টাইপে একই ধরনের আচরণ প্রয়োগ করা যেতে পারে, এবং Traits-এ default methods ব্যবহার করে ডিফল্ট আচরণ দেওয়া সম্ভব।
• Traits bounds ব্যবহার করে কোনো টাইপের জন্য নির্দিষ্ট Trait বাস্তবায়ন নিশ্চিত করা যায়, যার মাধ্যমে আরও শক্তিশালী এবং নমনীয় কোড লেখা সম্ভব।

Generics in Rust

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

Generics এর মূল বৈশিষ্ট্য:

• ফাংশন ও স্ট্রাকচারের জন্য টাইপ প্যারামিটার: যেগুলি একাধিক টাইপের জন্য কাজ করতে পারে।
• কম্পাইল টাইমে টাইপ চেকিং: রাস্ট টাইপ প্যারামিটারগুলির জন্য কম্পাইল টাইমে নিরাপত্তা নিশ্চিত করে।

উদাহরণ: Generics in Functions

fn print<T>(value: T) {
    println!("{:?}", value); // T টাইপের যে কোন মান প্রিন্ট করবে
}

fn main() {
    print(42); // i32
    print("Hello, Rust!"); // &str
}

এখানে, print ফাংশনটি T নামক টাইপ প্যারামিটার গ্রহণ করছে, যা যেকোনো টাইপের ডেটাকে প্রিন্ট করতে পারে।

উদাহরণ: Generics in Structs

struct Pair<T, U> {
    first: T,
    second: U,
}

fn main() {
    let p = Pair { first: 1, second: "Rust" };
    println!("First: {}, Second: {}", p.first, p.second);
}

এখানে, Pair স্ট্রাকচারটি দুটি জেনেরিক প্যারামিটার T এবং U গ্রহণ করছে, যার মাধ্যমে এটি যেকোনো দুই ধরনের ডেটা সংরক্ষণ করতে সক্ষম।

Trait Bounds in Rust

Trait Bounds হল এমন একটি ফিচার যা আপনাকে জেনেরিক টাইপের উপর কিছু সীমাবদ্ধতা প্রয়োগ করতে দেয়। এটি আপনাকে জেনেরিক টাইপের জন্য কিছু শর্ত বা বাধ্যবাধকতা আরোপ করতে সাহায্য করে, যেমন ফাংশনটি যে টাইপ নিয়ে কাজ করবে তা একটি নির্দিষ্ট ট্রেইট (Trait) ইমপ্লিমেন্ট করা উচিত।

Trait Bounds Syntax:

ট্রেইট বাউন্ড যুক্ত করতে where কিওয়ার্ড বা <T: Trait> সিনট্যাক্স ব্যবহার করা হয়।

উদাহরণ: Trait Bounds in Functions

use std::cmp::Ord;

fn largest<T: Ord>(list: &[T]) -> T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    *largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("The largest number is: {}", result);
}

এখানে, largest ফাংশনটি একটি জেনেরিক টাইপ T নিয়ে কাজ করছে, এবং T টাইপের জন্য Ord ট্রেইট বাউন্ডটি প্রয়োগ করা হয়েছে। এটি নিশ্চিত করে যে, T টাইপের ডেটার মধ্যে তুলনা (comparison) করা যাবে।

উদাহরণ: Trait Bounds in Structs

use std::fmt::Display;

struct Wrapper<T> {
    value: T,
}

impl<T: Display> Wrapper<T> {
    fn print(&self) {
        println!("{}", self.value);
    }
}

fn main() {
    let w = Wrapper { value: "Hello, Rust!" };
    w.print(); // works because T implements Display
}

এখানে, Wrapper স্ট্রাকচারের জন্য T টাইপের উপর Display ট্রেইট বাউন্ড প্রয়োগ করা হয়েছে, যার মানে হলো T টাইপের যেকোনো ডেটাকে println! এর মাধ্যমে প্রদর্শন করা যাবে।

Lifetimes in Rust

Lifetimes হল রাস্টের এমন একটি ধারণা যা আপনাকে মেমোরি নিরাপত্তা নিশ্চিত করতে সাহায্য করে। এটি মূলত জীবনকাল (lifetime) পরিচালনার জন্য ব্যবহৃত হয়, যাতে কম্পাইলার ডেটার রেফারেন্স সঠিকভাবে অ্যাক্সেস এবং মুক্ত করার সিদ্ধান্ত নিতে পারে।

Lifetimes Syntax:

রাস্টে জীবনের সময়সীমা (lifetime) একটি রেফারেন্সের সাথে সম্পর্কিত হয় এবং এটি & সাইন দিয়ে নির্দিষ্ট করা হয়। lifetime বাউন্ড ব্যবহার করতে <'a> সিনট্যাক্স ব্যবহার করা হয়।

উদাহরণ: Lifetime Annotations in Functions

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let string1 = String::from("Hello");
    let string2 = String::from("Rust");
    let result = longest(&string1, &string2);
    println!("The longest string is: {}", result);
}

এখানে, longest ফাংশনটির দুইটি ইনপুট রেফারেন্স এবং একটি রিটার্ন রেফারেন্সের জন্য lifetime 'a নির্দিষ্ট করা হয়েছে। এটি নিশ্চিত করে যে, s1 এবং s2 রেফারেন্সের লাইফটাইম ফাংশনের রিটার্ন রেফারেন্সের লাইফটাইমের সমান বা তার চেয়ে বড়।

উদাহরণ: Lifetime in Structs

struct Book<'a> {
    title: &'a str,
    author: &'a str,
}

fn main() {
    let title = String::from("Rust Programming");
    let author = String::from("John Doe");

    let book = Book {
        title: &title,
        author: &author,
    };

    println!("Book: {} by {}", book.title, book.author);
}

এখানে, Book স্ট্রাকচারে 'a নামক লাইফটাইম অ্যানোটেশন ব্যবহার করা হয়েছে যা স্ট্রাকচারের title এবং author রেফারেন্সগুলোর লাইফটাইম নির্দেশ করে।

Generics, Trait Bounds এবং Lifetimes এর সাথে একত্রিত ব্যবহার

এই তিনটি ধারণার একত্রিত ব্যবহার কিছুটা চ্যালেঞ্জিং হতে পারে, তবে এগুলি একসাথে ব্যবহৃত হলে অনেক শক্তিশালী প্রোগ্রাম তৈরি করা সম্ভব। সাধারণত, যখন আপনি জেনেরিক টাইপ, ট্রেইট বাউন্ড এবং লাইফটাইম একত্রিত করেন, তখন আপনি বেশ শক্তিশালী এবং মেমোরি নিরাপদ কোড লিখতে পারেন।

উদাহরণ: Generics, Trait Bounds, and Lifetimes Together

use std::fmt::Display;

fn longest<'a, T>(s1: &'a str, s2: &'a str, t: T) -> &'a str
where
    T: Display,
{
    println!("T value: {}", t);
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let string1 = String::from("Rust");
    let string2 = String::from("Programming");
    let result = longest(&string1, &string2, 42);
    println!("The longest string is: {}", result);
}

এখানে, longest ফাংশনটি জেনেরিক টাইপ T এবং লাইফটাইম 'a নেয়। T টাইপের জন্য Display ট্রেইট বাউন্ড এবং 'a লাইফটাইম অ্যানোটেশন ব্যবহার করা হয়েছে।

সারাংশ

• Generics রাস্টে কোডের পুনঃব্যবহারযোগ্যতা এবং নমনীয়তা নিশ্চিত করে।
• Trait Bounds ব্যবহারের মাধ্যমে আপনি জেনেরিক টাইপের জন্য কিছু শর্ত আরোপ করতে পারেন, যেমন ট্রেইট ইমপ্লিমেন্টেশন।
• Lifetimes রাস্টে মেমোরি নিরাপত্তা নিশ্চিত করতে সাহায্য করে এবং রেফারেন্সগুলোর লাইফটাইম সঠিকভাবে পরিচালনা করে।

এই তিনটি বৈশিষ্ট্য একত্রিত হয়ে রাস্টে আরও শক্তিশালী এবং নিরাপদ কোড লেখা সম্ভব করে তোলে।

Traits কী?

Rust এ traits হল একটি বৈশিষ্ট্য যা কোনো টাইপের জন্য একটি নির্দিষ্ট আচরণ বা ফাংশনালিটি সংজ্ঞায়িত করে। এটি কার্যকরভাবে interface এর মত কাজ করে, যা বিভিন্ন টাইপে একই ফাংশনালিটি যোগ করতে সাহায্য করে। একটি trait ডিফাইন করা হলে, সেটি অন্যান্য টাইপে (struct, enum) বাস্তবায়িত (implement) করা যেতে পারে, যার মাধ্যমে ঐ টাইপগুলো সেই trait এর ফাংশনগুলিকে কার্যকরভাবে ব্যবহার করতে পারে।

Custom Traits তৈরি করা

রাস্টে কাস্টম traits তৈরি করার জন্য প্রথমে trait কিওয়ার্ড ব্যবহার করে trait সংজ্ঞায়িত করতে হয়। এরপর, সেই trait এর মধ্যে এক বা একাধিক মেথড (function) নির্ধারণ করা হয়, যেগুলি ঐ trait কে বাস্তবায়িত (implement) করা টাইপে ব্যবহার করা যাবে।

উদাহরণ ১: Basic Custom Trait

এখানে আমরা একটি সাধারণ কাস্টম trait Descriptive তৈরি করব, যা একটি describe মেথড সংজ্ঞায়িত করবে।

// Trait সংজ্ঞায়িত করা
trait Descriptive {
    fn describe(&self) -> String; // মেথডের সিগনেচার
}

// Struct তৈরি করা
struct Person {
    name: String,
    age: u32,
}

// Person এর জন্য Descriptive trait বাস্তবায়িত করা
impl Descriptive for Person {
    fn describe(&self) -> String {
        format!("{} is {} years old.", self.name, self.age)
    }
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
    };

    println!("{}", person.describe()); // "Alice is 30 years old."
}

এখানে:

• Descriptive trait একটি describe মেথড সংজ্ঞায়িত করেছে, যা একটি স্ট্রিং ফেরত দেবে।
• Person struct এর জন্য Descriptive trait বাস্তবায়ন করা হয়েছে, যেখানে describe মেথডে name এবং age ব্যবহার করে একটি বর্ণনা তৈরি করা হয়েছে।

Custom Traits with Default Methods

রাস্টে, আপনি একটি trait এর মধ্যে ডিফল্ট মেথডও সংজ্ঞায়িত করতে পারেন। এই ডিফল্ট মেথডটি impl ব্লকে পুনরায় বাস্তবায়ন না করেও ব্যবহার করা যাবে।

উদাহরণ ২: Trait with Default Method

// Trait সংজ্ঞায়িত করা
trait Greet {
    fn greet(&self) -> String {
        String::from("Hello, world!") // ডিফল্ট মেথড
    }
}

// Struct তৈরি করা
struct Person {
    name: String,
}

// Person এর জন্য Greet trait বাস্তবায়িত করা
impl Greet for Person {
    fn greet(&self) -> String {
        format!("Hello, {}!", self.name) // কাস্টম মেথড বাস্তবায়ন
    }
}

fn main() {
    let person = Person {
        name: String::from("Bob"),
    };

    // কাস্টম greet মেথড ব্যবহার করা
    println!("{}", person.greet()); // "Hello, Bob!"
}

এখানে:

• Greet trait এর মধ্যে একটি ডিফল্ট greet মেথড রয়েছে, যা "Hello, world!" রিটার্ন করবে।
• Person struct এর জন্য, greet মেথড কাস্টমাইজ করা হয়েছে, যেখানে name দিয়ে একটি ব্যাক্তিগত অভ্যর্থনা বার্তা তৈরি করা হয়েছে।

Trait Bounds (Generic Types)

কাস্টম traits এর সাহায্যে আপনি generic types এর জন্য নির্দিষ্ট সীমাবদ্ধতা (bounds) তৈরি করতে পারেন। এই ধারণাটি সাধারণত generic functions বা generic structs এর ক্ষেত্রে প্রযোজ্য।

উদাহরণ ৩: Trait Bound in Generic Function

// Trait সংজ্ঞায়িত করা
trait Summarizable {
    fn summarize(&self) -> String;
}

// Struct তৈরি করা
struct Article {
    title: String,
    content: String,
}

// Article এর জন্য Summarizable trait বাস্তবায়িত করা
impl Summarizable for Article {
    fn summarize(&self) -> String {
        format!("{} - {}", self.title, self.content)
    }
}

// Generic ফাংশন যা trait bound ব্যবহার করবে
fn print_summary<T: Summarizable>(item: T) {
    println!("{}", item.summarize());
}

fn main() {
    let article = Article {
        title: String::from("Rust is Awesome!"),
        content: String::from("Rust provides memory safety and concurrency."),
    };

    print_summary(article); // "Rust is Awesome! - Rust provides memory safety and concurrency."
}

এখানে:

• Summarizable trait একটি summarize মেথড সংজ্ঞায়িত করেছে।
• Article struct এর জন্য Summarizable trait বাস্তবায়িত হয়েছে।
• print_summary একটি generic ফাংশন যা Summarizable trait এর সাথে bound, অর্থাৎ যেকোনো টাইপ যেটি Summarizable trait বাস্তবায়ন করেছে, সেটি এই ফাংশনকে আর্গুমেন্ট হিসেবে প্রদান করা যাবে।

Trait Inheritance (Trait Bounds)

রাস্টে, এক trait অন্য trait থেকে বৈশিষ্ট্য নিতে পারে, যা "trait inheritance" এর মতো কাজ করে। এটি trait bounds ব্যবহার করে করা হয়, যেখানে একটি trait অন্য trait এর method গুলি ব্যবহার করতে পারে।

উদাহরণ ৪: Trait Inheritance

// Basic trait সংজ্ঞায়িত করা
trait Speak {
    fn speak(&self);
}

// আরও একটি trait তৈরি করা যা Speak এর বৈশিষ্ট্য ধারণ করবে
trait Greet: Speak {
    fn greet(&self) {
        println!("Hello!");
        self.speak(); // Speak trait এর speak মেথড ব্যবহার
    }
}

// Struct তৈরি করা
struct Person {
    name: String,
}

// Person এর জন্য Speak এবং Greet trait বাস্তবায়িত করা
impl Speak for Person {
    fn speak(&self) {
        println!("My name is {}", self.name);
    }
}

impl Greet for Person {}

fn main() {
    let person = Person {
        name: String::from("Alice"),
    };

    person.greet(); // "Hello!" এবং "My name is Alice"
}

এখানে:

• Greet traitটি Speak trait কে inherit করেছে, এবং speak মেথডকে ব্যবহার করতে সক্ষম হয়েছে।
• Person struct উভয় trait বাস্তবায়ন করেছে, এবং greet মেথড কল করার মাধ্যমে speak মেথডকে ব্যবহার করেছে।

সারাংশ

• Custom Traits তৈরি করার মাধ্যমে আপনি একটি নির্দিষ্ট আচরণ বা ফাংশনালিটি তৈরি করতে পারেন, যা অন্য টাইপে বাস্তবায়ন করতে পারেন।
• আপনি কাস্টম traits এর মধ্যে ডিফল্ট মেথড সংজ্ঞায়িত করতে পারেন এবং generic functions বা generic structs এ trait bounds ব্যবহার করতে পারেন।
• Trait inheritance এর মাধ্যমে এক trait অন্য trait এর বৈশিষ্ট্য গ্রহণ করতে পারে, যা কোড পুনঃব্যবহারে সহায়ক।