fn main() {
    println!("Hello, world!");
}

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

$ cargo build
  Updating crates.io index
   Locking 15 packages to latest Rust 1.85.0 compatible versions
    Adding rand v0.8.5 (available: v0.9.0)
 Compiling proc-macro2 v1.0.93
 Compiling unicode-ident v1.0.17
 Compiling libc v0.2.170
 Compiling cfg-if v1.0.0
 Compiling byteorder v1.5.0
 Compiling getrandom v0.2.15
 Compiling rand_core v0.6.4
 Compiling quote v1.0.38
 Compiling syn v2.0.98
 Compiling zerocopy-derive v0.7.35
 Compiling zerocopy v0.7.35
 Compiling ppv-lite86 v0.2.20
 Compiling rand_chacha v0.3.1
 Compiling rand v0.8.5
 Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
  Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.48s```

</Listing>

আপনি ভিন্ন ভার্সন নম্বর দেখতে পারেন (কিন্তু SemVer-এর কারণে সেগুলি সব কোডের সাথে সামঞ্জস্যপূর্ণ হবে) এবং ভিন্ন লাইন দেখতে পারেন (অপারেটিং সিস্টেমের উপর নির্ভর করে), এবং লাইনগুলি ভিন্ন ক্রমে থাকতে পারে।

যখন আমরা একটি এক্সটার্নাল ডিপেন্ডেন্সি অন্তর্ভুক্ত করি, কার্গো সেই ডিপেন্ডেন্সির জন্য প্রয়োজনীয় সমস্ত কিছুর সর্বশেষ ভার্সন _registry_ থেকে নিয়ে আসে, যা [Crates.io][cratesio] থেকে ডেটার একটি কপি। Crates.io হল সেই জায়গা যেখানে রাস্ট ইকোসিস্টেমের মানুষজন তাদের ওপেন সোর্স রাস্ট প্রজেক্টগুলো অন্যদের ব্যবহারের জন্য পোস্ট করে।

রেজিস্ট্রি আপডেট করার পরে, কার্গো `[dependencies]` সেকশন পরীক্ষা করে এবং তালিকাভুক্ত যেকোনো crate যা এখনও ডাউনলোড করা হয়নি তা ডাউনলোড করে। এই ক্ষেত্রে, যদিও আমরা কেবল `rand`-কে একটি ডিপেন্ডেন্সি হিসেবে তালিকাভুক্ত করেছি, কার্গো `rand`-এর কাজ করার জন্য প্রয়োজনীয় অন্যান্য crate-গুলিও নিয়ে এসেছে। crate-গুলি ডাউনলোড করার পরে, রাস্ট সেগুলি কম্পাইল করে এবং তারপর ডিপেন্ডেন্সি সহ প্রজেক্টটি কম্পাইল করে।

আপনি যদি কোনো পরিবর্তন না করে অবিলম্বে আবার `cargo build` চালান, আপনি `Finished` লাইন ছাড়া আর কোনো আউটপুট পাবেন না। কার্গো জানে যে এটি ইতিমধ্যে ডিপেন্ডেন্সিগুলি ডাউনলোড এবং কম্পাইল করেছে, এবং আপনি আপনার _Cargo.toml_ ফাইলে সেগুলি সম্পর্কে কিছু পরিবর্তন করেননি। কার্গো এটাও জানে যে আপনি আপনার কোড সম্পর্কে কিছু পরিবর্তন করেননি, তাই এটি সেটাও পুনরায় কম্পাইল করে না। করার মতো কিছু না থাকায়, এটি কেবল প্রস্থান করে।

আপনি যদি _src/main.rs_ ফাইলটি খোলেন, একটি তুচ্ছ পরিবর্তন করেন, এবং তারপর এটি সংরক্ষণ করে আবার বিল্ড করেন, আপনি কেবল দুটি আউটপুট লাইন দেখতে পাবেন:

<!-- manual-regeneration
cd listings/ch02-guessing-game-tutorial/listing-02-02/
touch src/main.rs
cargo build -->

```console
$ cargo build
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s

এই লাইনগুলি দেখায় যে কার্গো কেবল আপনার src/main.rs ফাইলের ক্ষুদ্র পরিবর্তনের সাথে বিল্ড আপডেট করে। আপনার ডিপেন্ডেন্সিগুলি পরিবর্তিত হয়নি, তাই কার্গো জানে যে এটি সেগুলির জন্য যা ইতিমধ্যে ডাউনলোড এবং কম্পাইল করেছে তা পুনরায় ব্যবহার করতে পারে।

Cargo.lock ফাইলের মাধ্যমে পুনরুৎপাদনযোগ্য বিল্ড নিশ্চিত করা

কার্গোর একটি মেকানিজম রয়েছে যা নিশ্চিত করে যে আপনি বা অন্য কেউ আপনার কোড বিল্ড করার সময় প্রতিবার একই আর্টিফ্যাক্ট পুনর্নির্মাণ করতে পারবেন: কার্গো কেবল আপনার নির্দিষ্ট করা ডিপেন্ডেন্সিগুলির ভার্সন ব্যবহার করবে যতক্ষণ না আপনি অন্যথায় নির্দেশ দেন। উদাহরণস্বরূপ, ধরা যাক আগামী সপ্তাহে rand crate-এর 0.8.6 ভার্সন আসে, এবং সেই ভার্সনে একটি গুরুত্বপূর্ণ বাগ ফিক্স রয়েছে, কিন্তু এতে একটি রিগ্রেশনও রয়েছে যা আপনার কোড ভেঙে দেবে। এটি সামলাতে, রাস্ট প্রথমবার cargo build চালানোর সময় Cargo.lock ফাইল তৈরি করে, তাই এখন আমাদের guessing_game ডিরেক্টরিতে এটি রয়েছে।

যখন আপনি প্রথমবার একটি প্রজেক্ট বিল্ড করেন, কার্গো ডিপেন্ডেন্সিগুলির সমস্ত ভার্সন বের করে যা মানদণ্ড পূরণ করে এবং তারপরে সেগুলি Cargo.lock ফাইলে লেখে। ভবিষ্যতে যখন আপনি আপনার প্রজেক্ট বিল্ড করবেন, কার্গো দেখবে যে Cargo.lock ফাইলটি বিদ্যমান এবং সেখানে নির্দিষ্ট ভার্সনগুলি ব্যবহার করবে, আবার ভার্সন বের করার সমস্ত কাজ না করে। এটি আপনাকে স্বয়ংক্রিয়ভাবে একটি পুনরুৎপাদনযোগ্য বিল্ড পেতে দেয়। অন্য কথায়, আপনার প্রজেক্ট 0.8.5-এ থাকবে যতক্ষণ না আপনি স্পষ্টভাবে আপগ্রেড করেন, Cargo.lock ফাইলের কারণে। যেহেতু Cargo.lock ফাইলটি পুনরুৎপাদনযোগ্য বিল্ডের জন্য গুরুত্বপূর্ণ, তাই এটি প্রায়শই আপনার প্রজেক্টের বাকি কোডের সাথে সোর্স কন্ট্রোলে চেক ইন করা হয়।

একটি নতুন ভার্সন পেতে একটি Crate আপডেট করা

যখন আপনি একটি crate আপডেট করতে চান, কার্গো update কমান্ড সরবরাহ করে, যা Cargo.lock ফাইলটিকে উপেক্ষা করবে এবং Cargo.toml-এ আপনার স্পেসিফিকেশনগুলির সাথে মানানসই সমস্ত সর্বশেষ ভার্সন খুঁজে বের করবে। কার্গো তারপর সেই ভার্সনগুলি Cargo.lock ফাইলে লিখবে। এই ক্ষেত্রে, কার্গো কেবল 0.8.5 এর চেয়ে বড় এবং 0.9.0 এর চেয়ে কম ভার্সন খুঁজবে। যদি rand crate-টি 0.8.6 এবং 0.9.0 এই দুটি নতুন ভার্সন প্রকাশ করে থাকে, তবে আপনি cargo update চালালে নিম্নলিখিতটি দেখতে পাবেন:

$ cargo update
    Updating crates.io index
     Locking 1 package to latest Rust 1.85.0 compatible version
    Updating rand v0.8.5 -> v0.8.6 (available: v0.9.0)

কার্গো 0.9.0 রিলিজটি উপেক্ষা করে। এই মুহূর্তে, আপনি আপনার Cargo.lock ফাইলে একটি পরিবর্তনও লক্ষ্য করবেন যা উল্লেখ করে যে আপনি এখন rand crate-এর যে ভার্সনটি ব্যবহার করছেন তা হল 0.8.6। rand ভার্সন 0.9.0 বা 0.9.x সিরিজের যেকোনো ভার্সন ব্যবহার করতে, আপনাকে Cargo.toml ফাইলটি আপডেট করে এমন দেখতে হবে:

[dependencies]
rand = "0.9.0"

পরবর্তীবার যখন আপনি cargo build চালাবেন, কার্গো উপলব্ধ crate-গুলির রেজিস্ট্রি আপডেট করবে এবং আপনার নির্দিষ্ট করা নতুন ভার্সন অনুযায়ী আপনার rand প্রয়োজনীয়তা পুনরায় মূল্যায়ন করবে।

কার্গো এবং এর ইকোসিস্টেম সম্পর্কে আরও অনেক কিছু বলার আছে, যা আমরা অধ্যায় ১৪-তে আলোচনা করব, কিন্তু আপাতত, আপনার এটুকুই জানা দরকার। কার্গো লাইব্রেরি পুনঃব্যবহার করা খুব সহজ করে তোলে, তাই রাস্টেশিয়ানরা ছোট ছোট প্রজেক্ট লিখতে পারে যা বিভিন্ন প্যাকেজ থেকে একত্রিত হয়।

একটি র‍্যান্ডম সংখ্যা তৈরি করা

চলুন অনুমান করার জন্য একটি সংখ্যা তৈরি করতে rand ব্যবহার করা শুরু করি। পরবর্তী ধাপ হল src/main.rs আপডেট করা, যেমনটি লিস্টিং ২-৩-এ দেখানো হয়েছে।

use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

প্রথমে আমরা use rand::Rng; লাইনটি যোগ করি। Rng ট্রেইটটি র‍্যান্ডম নম্বর জেনারেটর দ্বারা প্রয়োগ করা মেথডগুলিকে সংজ্ঞায়িত করে, এবং এই ট্রেইটটি আমাদের সেই মেথডগুলি ব্যবহার করার জন্য স্কোপে থাকতে হবে। অধ্যায় ১০-এ ট্রেইটগুলি বিস্তারিতভাবে আলোচনা করা হবে।

এরপরে, আমরা মাঝখানে দুটি লাইন যোগ করছি। প্রথম লাইনে, আমরা rand::thread_rng ফাংশনটি কল করি যা আমাদের নির্দিষ্ট র‍্যান্ডম নম্বর জেনারেটর দেয় যা আমরা ব্যবহার করতে যাচ্ছি: এটি বর্তমান এক্সিকিউশন থ্রেডের জন্য স্থানীয় এবং অপারেটিং সিস্টেম দ্বারা সিড করা হয়। তারপরে আমরা র‍্যান্ডম নম্বর জেনারেটরে gen_range মেথডটি কল করি। এই মেথডটি Rng ট্রেইট দ্বারা সংজ্ঞায়িত যা আমরা use rand::Rng; স্টেটমেন্ট দিয়ে স্কোপে এনেছিলাম। gen_range মেথডটি একটি রেঞ্জ এক্সপ্রেশনকে আর্গুমেন্ট হিসেবে নেয় এবং সেই রেঞ্জের মধ্যে একটি র‍্যান্ডম নম্বর তৈরি করে। আমরা এখানে যে ধরনের রেঞ্জ এক্সপ্রেশন ব্যবহার করছি তা start..=end আকারে থাকে এবং এটি নিম্ন এবং উচ্চ উভয় সীমার জন্যই অন্তর্ভুক্ত, তাই ১ থেকে ১০০ এর মধ্যে একটি সংখ্যা অনুরোধ করার জন্য আমাদের 1..=100 নির্দিষ্ট করতে হবে।

দ্রষ্টব্য: আপনি কেবল জেনেই যাবেন না কোন ট্রেইট ব্যবহার করতে হবে এবং কোন মেথড এবং ফাংশনগুলি একটি crate থেকে কল করতে হবে, তাই প্রতিটি crate-এর ডকুমেন্টেশনে এটি ব্যবহারের জন্য নির্দেশাবলী থাকে। কার্গোর আরেকটি চমৎকার বৈশিষ্ট্য হল cargo doc --open কমান্ডটি চালালে এটি আপনার সমস্ত ডিপেন্ডেন্সি দ্বারা সরবরাহ করা ডকুমেন্টেশন স্থানীয়ভাবে তৈরি করবে এবং আপনার ব্রাউজারে খুলবে। আপনি যদি rand crate-এর অন্যান্য কার্যকারিতা সম্পর্কে আগ্রহী হন, উদাহরণস্বরূপ, cargo doc --open চালান এবং বামদিকের সাইডবারে rand-এ ক্লিক করুন।

দ্বিতীয় নতুন লাইনটি গোপন সংখ্যাটি প্রিন্ট করে। এটি প্রোগ্রাম ডেভেলপ করার সময় পরীক্ষা করার জন্য দরকারী, কিন্তু আমরা চূড়ান্ত সংস্করণ থেকে এটি মুছে ফেলব। প্রোগ্রাম শুরু হওয়ার সাথে সাথেই যদি উত্তরটি প্রিন্ট করে দেয় তবে এটি আর তেমন কোনো গেম থাকে না!

প্রোগ্রামটি কয়েকবার চালানোর চেষ্টা করুন:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4

$ cargo run
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5

আপনার বিভিন্ন র‍্যান্ডম সংখ্যা পাওয়া উচিত, এবং সেগুলি সবই ১ থেকে ১০০ এর মধ্যে সংখ্যা হওয়া উচিত। দারুণ কাজ!

অনুমানের সাথে গোপন সংখ্যার তুলনা

এখন আমাদের কাছে ব্যবহারকারীর ইনপুট এবং একটি র‍্যান্ডম সংখ্যা আছে, আমরা তাদের তুলনা করতে পারি। সেই ধাপটি লিস্টিং ২-৪-এ দেখানো হয়েছে। মনে রাখবেন যে এই কোডটি এখনই কম্পাইল হবে না, যেমনটি আমরা ব্যাখ্যা করব।

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    // --snip--
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

প্রথমে আমরা আরেকটি use স্টেটমেন্ট যোগ করি, যা স্ট্যান্ডার্ড লাইব্রেরি থেকে std::cmp::Ordering নামে একটি টাইপ স্কোপে নিয়ে আসে। Ordering টাইপটি আরেকটি enum এবং এর ভ্যারিয়েন্টগুলি হল Less, Greater, এবং Equal। এগুলি হল তিনটি সম্ভাব্য ফলাফল যা আপনি দুটি মান তুলনা করার সময় পেতে পারেন।

তারপর আমরা নীচে পাঁচটি নতুন লাইন যোগ করি যা Ordering টাইপ ব্যবহার করে। cmp মেথড দুটি মান তুলনা করে এবং যা কিছু তুলনা করা যায় তার উপর কল করা যেতে পারে। এটি আপনি যার সাথে তুলনা করতে চান তার একটি রেফারেন্স নেয়: এখানে এটি guess-কে secret_number-এর সাথে তুলনা করছে। তারপর এটি Ordering enum-এর একটি ভ্যারিয়েন্ট প্রদান করে যা আমরা use স্টেটমেন্ট দিয়ে স্কোপে এনেছিলাম। আমরা একটি match এক্সপ্রেশন ব্যবহার করি guess এবং secret_number-এর মানগুলির সাথে cmp-কে কল করার ফলে Ordering-এর কোন ভ্যারিয়েন্টটি ফেরত এসেছে তার উপর ভিত্তি করে পরবর্তী কী করতে হবে তা সিদ্ধান্ত নিতে।

একটি match এক্সপ্রেশন arms (শাখা) দিয়ে গঠিত। একটি arm-এ একটি pattern (প্যাটার্ন) থাকে যার সাথে মেলানো হয়, এবং যে কোডটি চালানো উচিত যদি match-কে দেওয়া মানটি সেই arm-এর প্যাটার্নের সাথে মিলে যায়। রাস্ট match-কে দেওয়া মানটি নেয় এবং প্রতিটি arm-এর প্যাটার্ন একের পর এক পরীক্ষা করে। প্যাটার্ন এবং match কনস্ট্রাক্ট হল শক্তিশালী রাস্ট বৈশিষ্ট্য: এগুলি আপনাকে আপনার কোড সম্মুখীন হতে পারে এমন বিভিন্ন পরিস্থিতি প্রকাশ করতে দেয় এবং তারা নিশ্চিত করে যে আপনি সেগুলি সবই পরিচালনা করেছেন। এই বৈশিষ্ট্যগুলি যথাক্রমে অধ্যায় ৬ এবং অধ্যায় ১৯-এ বিস্তারিতভাবে আলোচনা করা হবে।

চলুন আমরা এখানে যে match এক্সপ্রেশনটি ব্যবহার করছি তার একটি উদাহরণ দিয়ে হেঁটে যাই। ধরা যাক ব্যবহারকারী ৫০ অনুমান করেছে এবং এইবার র‍্যান্ডমভাবে তৈরি গোপন সংখ্যাটি হল ৩৮।

যখন কোডটি ৫০ কে ৩৮ এর সাথে তুলনা করে, cmp মেথডটি Ordering::Greater প্রদান করবে কারণ ৫০, ৩৮ এর চেয়ে বড়। match এক্সপ্রেশনটি Ordering::Greater মানটি পায় এবং প্রতিটি arm-এর প্যাটার্ন পরীক্ষা করা শুরু করে। এটি প্রথম arm-এর প্যাটার্ন, Ordering::Less-এর দিকে তাকায় এবং দেখে যে Ordering::Greater মানটি Ordering::Less-এর সাথে মেলে না, তাই এটি সেই arm-এর কোডটি উপেক্ষা করে এবং পরবর্তী arm-এ চলে যায়। পরবর্তী arm-এর প্যাটার্ন হল Ordering::Greater, যা Ordering::Greater-এর সাথে মিলে যায়! সেই arm-এর সংশ্লিষ্ট কোডটি কার্যকর হবে এবং স্ক্রিনে Too big! প্রিন্ট করবে। match এক্সপ্রেশনটি প্রথম সফল ম্যাচের পরে শেষ হয়ে যায়, তাই এটি এই পরিস্থিতিতে শেষ arm-টি দেখবে না।

তবে, লিস্টিং ২-৪-এর কোডটি এখনও কম্পাইল হবে না। চলুন চেষ্টা করি:

$ cargo build
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.5
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
  --> src/main.rs:23:21
   |
23 |     match guess.cmp(&secret_number) {
   |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
   |                 |
   |                 arguments to this method are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: method defined here
  --> /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/cmp.rs:964:8

For more information about this error, try `rustc --explain E0308`.
error: could not compile `guessing_game` (bin "guessing_game") due to 1 previous error

ত্রুটির মূল কথা হল mismatched types (বেমানান টাইপ)। রাস্টের একটি শক্তিশালী, স্ট্যাটিক টাইপ সিস্টেম আছে। তবে, এর টাইপ ইনফারেন্সও আছে। যখন আমরা let mut guess = String::new() লিখেছিলাম, রাস্ট অনুমান করতে পেরেছিল যে guess একটি String হওয়া উচিত এবং আমাদের টাইপ লিখতে বাধ্য করেনি। অন্যদিকে, secret_number একটি সংখ্যা টাইপ। রাস্টের কয়েকটি সংখ্যা টাইপের মান ১ থেকে ১০০ এর মধ্যে থাকতে পারে: i32, একটি ৩২-বিট সংখ্যা; u32, একটি আনসাইন্ড ৩২-বিট সংখ্যা; i64, একটি ৬৪-বিট সংখ্যা; এবং আরও অন্যান্য। অন্যথায় নির্দিষ্ট না করা হলে, রাস্ট ডিফল্ট হিসেবে i32 ব্যবহার করে, যা secret_number-এর টাইপ, যদি না আপনি অন্য কোথাও টাইপ তথ্য যোগ করেন যা রাস্টকে একটি ভিন্ন সংখ্যাসূচক টাইপ অনুমান করতে বাধ্য করবে। ত্রুটির কারণ হল রাস্ট একটি স্ট্রিং এবং একটি সংখ্যা টাইপের তুলনা করতে পারে না।

শেষ পর্যন্ত, আমরা প্রোগ্রামটি ইনপুট হিসাবে যে String পড়ে তা একটি সংখ্যা টাইপে রূপান্তর করতে চাই যাতে আমরা এটিকে গোপন সংখ্যার সাথে সংখ্যাগতভাবে তুলনা করতে পারি। আমরা main ফাংশনের বডিতে এই লাইনটি যোগ করে তা করি:

ফাইলের নাম: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    // --snip--

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

লাইনটি হল:

let guess: u32 = guess.trim().parse().expect("Please type a number!");

আমরা guess নামে একটি ভ্যারিয়েবল তৈরি করি। কিন্তু অপেক্ষা করুন, প্রোগ্রামে কি ইতিমধ্যে guess নামে একটি ভ্যারিয়েবল নেই? আছে, কিন্তু সহায়কভাবে রাস্ট আমাদের guess-এর পূর্ববর্তী মানটিকে একটি নতুন মান দিয়ে শ্যাডো (shadow) করার অনুমতি দেয়। Shadowing আমাদের guess ভ্যারিয়েবলের নামটি পুনরায় ব্যবহার করতে দেয়, যেমন guess_str এবং guess নামে দুটি অনন্য ভ্যারিয়েবল তৈরি করতে বাধ্য করার পরিবর্তে। আমরা এটি অধ্যায় ৩-এ আরও বিস্তারিতভাবে আলোচনা করব, কিন্তু আপাতত, জেনে রাখুন যে এই বৈশিষ্ট্যটি প্রায়শই ব্যবহৃত হয় যখন আপনি একটি মানকে এক টাইপ থেকে অন্য টাইপে রূপান্তর করতে চান।

আমরা এই নতুন ভ্যারিয়েবলটিকে guess.trim().parse() এক্সপ্রেশনের সাথে বাইন্ড করি। এক্সপ্রেশনের guess মূল guess ভ্যারিয়েবলটিকে বোঝায় যা ইনপুটটিকে একটি স্ট্রিং হিসাবে ধারণ করেছিল। একটি String ইনস্ট্যান্সের trim মেথড শুরু এবং শেষের যেকোনো হোয়াইটস্পেস দূর করে দেবে, যা আমাদের স্ট্রিংটিকে একটি u32-তে রূপান্তর করার আগে করতে হবে, যা কেবল সংখ্যাসূচক ডেটা ধারণ করতে পারে। ব্যবহারকারীকে read_line সন্তুষ্ট করতে এবং তাদের অনুমান ইনপুট করতে enter চাপতে হবে, যা স্ট্রিংটিতে একটি নিউলাইন ক্যারেক্টার যোগ করে। উদাহরণস্বরূপ, যদি ব্যবহারকারী 5 টাইপ করে এবং enter চাপে, guess দেখতে এমন হয়: 5\n। \n "নিউলাইন" প্রতিনিধিত্ব করে। (উইন্ডোজে, enter চাপলে একটি ক্যারেজ রিটার্ন এবং একটি নিউলাইন হয়, \r\n।) trim মেথড \n বা \r\n দূর করে, যার ফলে কেবল 5 থাকে।

স্ট্রিং-এর উপর parse মেথড একটি স্ট্রিংকে অন্য টাইপে রূপান্তর করে। এখানে, আমরা এটিকে একটি স্ট্রিং থেকে একটি সংখ্যায় রূপান্তর করতে ব্যবহার করি। আমাদের রাস্টকে let guess: u32 ব্যবহার করে ঠিক কোন সংখ্যা টাইপ আমরা চাই তা বলতে হবে। guess-এর পরে কোলন (:) রাস্টকে বলে যে আমরা ভ্যারিয়েবলের টাইপ অ্যানোটেট করব। রাস্টের কয়েকটি অন্তর্নির্মিত সংখ্যা টাইপ আছে; এখানে দেখা u32 একটি আনসাইন্ড, ৩২-বিট ইন্টিজার। এটি একটি ছোট ধনাত্মক সংখ্যার জন্য একটি ভাল ডিফল্ট পছন্দ। আপনি অধ্যায় ৩-এ অন্যান্য সংখ্যা টাইপ সম্পর্কে শিখবেন।

উপরন্তু, এই উদাহরণ প্রোগ্রামে u32 অ্যানোটেশন এবং secret_number-এর সাথে তুলনা করার মানে হল রাস্ট অনুমান করবে যে secret_number-ও একটি u32 হওয়া উচিত। তাই এখন তুলনাটি একই টাইপের দুটি মানের মধ্যে হবে!

parse মেথডটি কেবল সেই অক্ষরগুলির উপর কাজ করবে যেগুলিকে যৌক্তিকভাবে সংখ্যায় রূপান্তর করা যায় এবং তাই সহজেই ত্রুটি ঘটাতে পারে। উদাহরণস্বরূপ, যদি স্ট্রিংটিতে A👍% থাকে, তবে সেটিকে সংখ্যায় রূপান্তর করার কোনো উপায় থাকবে না। কারণ এটি ব্যর্থ হতে পারে, parse মেথডটি একটি Result টাইপ প্রদান করে, যেমনটি read_line মেথড করে (আগে “Handling Potential Failure with Result” বিভাগে আলোচনা করা হয়েছে)। আমরা এই Result-কে আবার expect মেথড ব্যবহার করে একইভাবে ব্যবহার করব। যদি parse একটি Err Result ভ্যারিয়েন্ট প্রদান করে কারণ এটি স্ট্রিং থেকে একটি সংখ্যা তৈরি করতে পারেনি, expect কলটি গেমটি ক্র্যাশ করাবে এবং আমরা যে বার্তাটি দিই তা প্রিন্ট করবে। যদি parse সফলভাবে স্ট্রিংটিকে একটি সংখ্যায় রূপান্তর করতে পারে, তবে এটি Result-এর Ok ভ্যারিয়েন্ট প্রদান করবে, এবং expect Ok মান থেকে আমরা যে সংখ্যাটি চাই তা প্রদান করবে।

চলুন এখন প্রোগ্রামটি চালাই:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
  76
You guessed: 76
Too big!

সুন্দর! অনুমানের আগে স্পেস যোগ করা সত্ত্বেও, প্রোগ্রামটি এখনও বুঝতে পেরেছে যে ব্যবহারকারী ৭৬ অনুমান করেছে। বিভিন্ন ধরণের ইনপুটের সাথে বিভিন্ন আচরণ যাচাই করার জন্য প্রোগ্রামটি কয়েকবার চালান: সংখ্যাটি সঠিকভাবে অনুমান করুন, খুব বেশি একটি সংখ্যা অনুমান করুন, এবং খুব কম একটি সংখ্যা অনুমান করুন।

আমাদের গেমের বেশিরভাগই এখন কাজ করছে, কিন্তু ব্যবহারকারী কেবল একটি অনুমান করতে পারে। চলুন একটি লুপ যোগ করে এটি পরিবর্তন করি!

লুপিংয়ের মাধ্যমে একাধিক অনুমানের অনুমতি দেওয়া

loop কীওয়ার্ড একটি অসীম লুপ তৈরি করে। আমরা ব্যবহারকারীদের সংখ্যাটি অনুমান করার আরও সুযোগ দিতে একটি লুপ যোগ করব:

ফাইলের নাম: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    // --snip--

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        // --snip--


        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => println!("You win!"),
        }
    }
}

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

ব্যবহারকারী সর্বদা কীবোর্ড শর্টকাট ctrl-c ব্যবহার করে প্রোগ্রামটি বাধা দিতে পারে। কিন্তু এই অতৃপ্ত দৈত্য থেকে বাঁচার আরেকটি উপায় আছে, যেমনটি "Comparing the Guess to the Secret Number" বিভাগে parse আলোচনায় উল্লেখ করা হয়েছে: যদি ব্যবহারকারী একটি অ-সংখ্যা উত্তর প্রবেশ করায়, প্রোগ্রামটি ক্র্যাশ করবে। আমরা ব্যবহারকারীকে বের হওয়ার অনুমতি দিতে এর সুবিধা নিতে পারি, যেমনটি এখানে দেখানো হয়েছে:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.23s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit

thread 'main' panicked at src/main.rs:28:47:
Please type a number!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

quit টাইপ করলে গেমটি থেকে বের হয়ে যাবে, কিন্তু আপনি যেমন লক্ষ্য করবেন, অন্য যেকোনো অ-সংখ্যা ইনপুট প্রবেশ করালেও তাই হবে। এটি সর্বোত্তম থেকে অনেক দূরে; আমরা চাই যে সঠিক সংখ্যা অনুমান করা হলে গেমটি বন্ধ হয়ে যাক।

সঠিক অনুমানের পর খেলা শেষ করা

চলুন একটি break স্টেটমেন্ট যোগ করে গেমটি এমনভাবে প্রোগ্রাম করি যাতে ব্যবহারকারী জিতলে খেলাটি শেষ হয়ে যায়:

ফাইলের নাম: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

You win! এর পরে break লাইনটি যোগ করলে ব্যবহারকারী যখন গোপন সংখ্যাটি সঠিকভাবে অনুমান করে তখন প্রোগ্রামটি লুপ থেকে বেরিয়ে যায়। লুপ থেকে বেরিয়ে যাওয়ার মানে হল প্রোগ্রাম থেকে বেরিয়ে যাওয়া, কারণ লুপটি main-এর শেষ অংশ।

অবৈধ ইনপুট পরিচালনা করা

গেমের আচরণ আরও পরিমার্জিত করার জন্য, ব্যবহারকারী যখন একটি অ-সংখ্যা ইনপুট করে তখন প্রোগ্রামটি ক্র্যাশ করার পরিবর্তে, চলুন গেমটিকে একটি অ-সংখ্যা উপেক্ষা করতে বাধ্য করি যাতে ব্যবহারকারী অনুমান চালিয়ে যেতে পারে। আমরা এটি সেই লাইনটি পরিবর্তন করে করতে পারি যেখানে guess একটি String থেকে একটি u32-তে রূপান্তরিত হয়, যেমনটি লিস্টিং ২-৫-এ দেখানো হয়েছে।

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

আমরা একটি expect কল থেকে একটি match এক্সপ্রেশনে স্যুইচ করি যাতে একটি ত্রুটিতে ক্র্যাশ করার পরিবর্তে ত্রুটিটি পরিচালনা করা যায়। মনে রাখবেন যে parse একটি Result টাইপ প্রদান করে এবং Result একটি enum যার Ok এবং Err ভ্যারিয়েন্ট রয়েছে। আমরা এখানে একটি match এক্সপ্রেশন ব্যবহার করছি, যেমনটি আমরা cmp মেথডের Ordering ফলাফলের সাথে করেছিলাম।

যদি parse সফলভাবে স্ট্রিংটিকে একটি সংখ্যায় পরিণত করতে পারে, তবে এটি একটি Ok মান প্রদান করবে যা ফলস্বরূপ সংখ্যাটি ধারণ করে। সেই Ok মানটি প্রথম arm-এর প্যাটার্নের সাথে মিলবে, এবং match এক্সপ্রেশনটি কেবল parse দ্বারা উৎপাদিত এবং Ok মানের ভিতরে রাখা num মানটি প্রদান করবে। সেই সংখ্যাটি আমরা যে নতুন guess ভ্যারিয়েবলটি তৈরি করছি সেখানে ঠিক যেখানে আমরা চাই সেখানেই শেষ হবে।

যদি parse স্ট্রিংটিকে একটি সংখ্যায় পরিণত করতে না পারে, তবে এটি একটি Err মান প্রদান করবে যা ত্রুটি সম্পর্কে আরও তথ্য ধারণ করে। Err মানটি প্রথম match arm-এর Ok(num) প্যাটার্নের সাথে মেলে না, তবে এটি দ্বিতীয় arm-এর Err(_) প্যাটার্নের সাথে মেলে। আন্ডারস্কোর, _, একটি ক্যাচ-অল মান; এই উদাহরণে, আমরা বলছি যে আমরা সমস্ত Err মান মেলাতে চাই, তাদের ভিতরে যাই তথ্য থাকুক না কেন। তাই প্রোগ্রামটি দ্বিতীয় arm-এর কোড, continue, কার্যকর করবে, যা প্রোগ্রামকে loop-এর পরবর্তী পুনরাবৃত্তিতে যেতে এবং আরেকটি অনুমানের জন্য জিজ্ঞাসা করতে বলে। তাই, কার্যকরভাবে, প্রোগ্রামটি parse-এর সম্মুখীন হতে পারে এমন সমস্ত ত্রুটি উপেক্ষা করে!

এখন প্রোগ্রামের সবকিছু প্রত্যাশিতভাবে কাজ করা উচিত। চলুন চেষ্টা করি:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!

অসাধারণ! একটি ছোট চূড়ান্ত পরিবর্তনের মাধ্যমে, আমরা guessing game শেষ করব। মনে রাখবেন যে প্রোগ্রামটি এখনও গোপন সংখ্যাটি প্রিন্ট করছে। এটি পরীক্ষার জন্য ভাল কাজ করেছে, কিন্তু এটি গেমটি নষ্ট করে দেয়। চলুন গোপন সংখ্যাটি আউটপুট করে এমন println! টি মুছে ফেলি। লিস্টিং ২-৬ চূড়ান্ত কোডটি দেখায়।

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

এই মুহূর্তে, আপনি সফলভাবে guessing game তৈরি করেছেন। অভিনন্দন!

সারাংশ

এই প্রজেক্টটি আপনাকে অনেক নতুন রাস্ট কনসেপ্টের সাথে পরিচিত করার একটি বাস্তবসম্মত উপায় ছিল: let, match, ফাংশন, এক্সটার্নাল crate-এর ব্যবহার, এবং আরও অনেক কিছু। পরবর্তী কয়েকটি অধ্যায়ে, আপনি এই ধারণাগুলি সম্পর্কে আরও বিস্তারিতভাবে শিখবেন। অধ্যায় ৩ এমন ধারণাগুলি কভার করে যা বেশিরভাগ প্রোগ্রামিং ভাষাতেই আছে, যেমন ভ্যারিয়েবল, ডেটা টাইপ, এবং ফাংশন, এবং দেখায় কিভাবে রাস্ট-এ সেগুলি ব্যবহার করতে হয়। অধ্যায় ৪ ওনারশিপ অন্বেষণ করে, একটি বৈশিষ্ট্য যা রাস্টকে অন্যান্য ভাষা থেকে আলাদা করে। অধ্যায় ৫ struct এবং মেথড সিনট্যাক্স নিয়ে আলোচনা করে, এবং অধ্যায় ৬ ব্যাখ্যা করে কিভাবে enum কাজ করে।

সাধারণ প্রোগ্রামিং ধারণা

এই অধ্যায়ে এমন কিছু ধারণা নিয়ে আলোচনা করা হয়েছে যা প্রায় সব প্রোগ্রামিং ল্যাঙ্গুয়েজেই পাওয়া যায় এবং রাস্ট-এ সেগুলো কীভাবে কাজ করে। অনেক প্রোগ্রামিং ল্যাঙ্গুয়েজের মূল ভিত্তি প্রায় একই রকম। এই অধ্যায়ে উপস্থাপিত কোনো ধারণাই শুধু রাস্টের জন্য অনন্য নয়, তবে আমরা রাস্টের প্রেক্ষাপটে সেগুলো আলোচনা করব এবং এই ধারণাগুলো ব্যবহারের প্রচলিত নিয়মগুলো ব্যাখ্যা করব।

বিশেষ করে, আপনি ভ্যারিয়েবল, বেসিক টাইপ, ফাংশন, কমেন্ট এবং কন্ট্রোল ফ্লো সম্পর্কে শিখবেন। এই মৌলিক বিষয়গুলো প্রতিটি রাস্ট প্রোগ্রামে থাকবে, এবং এগুলো আগেভাগে শিখে নিলে আপনার শুরু করার জন্য একটি শক্তিশালী ভিত্তি তৈরি হবে।

Keywords

অন্যান্য ল্যাঙ্গুয়েজের মতোই, রাস্ট ল্যাঙ্গুয়েজেরও কিছু নির্দিষ্ট keywords আছে যা শুধুমাত্র ল্যাঙ্গুয়েজের ব্যবহারের জন্য সংরক্ষিত। মনে রাখবেন যে আপনি এই শব্দগুলোকে ভ্যারিয়েবল বা ফাংশনের নাম হিসেবে ব্যবহার করতে পারবেন না। বেশিরভাগ কীওয়ার্ডের বিশেষ অর্থ রয়েছে, এবং আপনি আপনার রাস্ট প্রোগ্রামে বিভিন্ন কাজ করার জন্য সেগুলি ব্যবহার করবেন; কিছু কীওয়ার্ডের সাথে বর্তমানে কোনো কার্যকারিতা যুক্ত নেই তবে ভবিষ্যতে রাস্ট-এ যুক্ত হতে পারে এমন কার্যকারিতার জন্য সংরক্ষিত রাখা হয়েছে। আপনি পরিশিষ্ট এ-তে কীওয়ার্ডগুলোর একটি তালিকা খুঁজে পেতে পারেন।

ভ্যারিয়েবল এবং পরিবর্তনশীলতা (Variables and Mutability)

যেমনটি "ভ্যারিয়েবলের মাধ্যমে মান সংরক্ষণ করা" বিভাগে উল্লেখ করা হয়েছে, ডিফল্টরূপে, ভ্যারিয়েবলগুলো অপরিবর্তনীয় (immutable)। এটি রাস্টের অনেকগুলো পদ্ধতির মধ্যে একটি যা আপনাকে কোড এমনভাবে লিখতে উৎসাহিত করে যা রাস্টের দেওয়া নিরাপত্তা এবং সহজ কনকারেন্সি (concurrency)-এর সুবিধা নেয়। তবে, আপনার কাছে আপনার ভ্যারিয়েবলগুলোকে পরিবর্তনযোগ্য (mutable) করার বিকল্পও রয়েছে। চলুন অন্বেষণ করি কীভাবে এবং কেন রাস্ট আপনাকে অপরিবর্তনীয়তাকে অগ্রাধিকার দিতে উৎসাহিত করে এবং কেন কখনও কখনও আপনি এর থেকে সরে আসতে চাইতে পারেন।

যখন একটি ভ্যারিয়েবল অপরিবর্তনীয় হয়, একবার একটি মান একটি নামের সাথে বাইন্ড করা হলে, আপনি সেই মান পরিবর্তন করতে পারবেন না। এটি দেখানোর জন্য, আপনার projects ডিরেক্টরিতে cargo new variables ব্যবহার করে variables নামে একটি নতুন প্রজেক্ট তৈরি করুন।

তারপর, আপনার নতুন variables ডিরেক্টরিতে, src/main.rs খুলুন এবং এর কোডটি নিম্নলিখিত কোড দিয়ে প্রতিস্থাপন করুন, যা এখনই কম্পাইল হবে না:

ফাইলের নাম: src/main.rs

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

cargo run ব্যবহার করে প্রোগ্রামটি সংরক্ষণ করুন এবং চালান। আপনি একটি অপরিবর্তনীয়তার ত্রুটি সম্পর্কিত একটি এরর বার্তা পাবেন, যেমনটি এই আউটপুটে দেখানো হয়েছে:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to 1 previous error

এই উদাহরণটি দেখায় কীভাবে কম্পাইলার আপনাকে আপনার প্রোগ্রামের ত্রুটি খুঁজে পেতে সাহায্য করে। কম্পাইলার এরর হতাশাজনক হতে পারে, কিন্তু আসলে এর মানে শুধু এই যে আপনার প্রোগ্রাম এখনও নিরাপদে যা করতে চায় তা করছে না; এর মানে এই নয় যে আপনি একজন ভাল প্রোগ্রামার নন! অভিজ্ঞ রাস্টেশিয়ানরাও কম্পাইলার এরর পান।

আপনি cannot assign twice to immutable variable `x` এরর বার্তাটি পেয়েছেন কারণ আপনি অপরিবর্তনীয় x ভ্যারিয়েবলে দ্বিতীয়বার একটি মান অ্যাসাইন করার চেষ্টা করেছেন।

যখন আমরা একটি মান পরিবর্তন করার চেষ্টা করি যা অপরিবর্তনীয় হিসাবে চিহ্নিত করা হয়েছে, তখন কম্পাইল-টাইম এরর পাওয়া গুরুত্বপূর্ণ কারণ এই পরিস্থিতিটি বাগের কারণ হতে পারে। যদি আমাদের কোডের একটি অংশ এই অনুমানের উপর কাজ করে যে একটি মান কখনও পরিবর্তন হবে না এবং আমাদের কোডের অন্য একটি অংশ সেই মানটি পরিবর্তন করে, তবে এটি সম্ভব যে কোডের প্রথম অংশটি যা করার জন্য ডিজাইন করা হয়েছিল তা করবে না। এই ধরনের বাগের কারণ পরে খুঁজে বের করা কঠিন হতে পারে, বিশেষ করে যখন দ্বিতীয় কোডটি কেবল মাঝে মাঝে মান পরিবর্তন করে। রাস্ট কম্পাইলার গ্যারান্টি দেয় যে যখন আপনি বলেন যে একটি মান পরিবর্তন হবে না, তখন এটি সত্যিই পরিবর্তন হবে না, তাই আপনাকে নিজে এটি ট্র্যাক রাখতে হবে না। আপনার কোড তাই বোঝা সহজ হয়।

কিন্তু পরিবর্তনশীলতা খুব দরকারী হতে পারে, এবং কোড লেখা আরও সুবিধাজনক করে তুলতে পারে। যদিও ভ্যারিয়েবলগুলো ডিফল্টরূপে অপরিবর্তনীয়, আপনি অধ্যায় ২-এর মতো ভ্যারিয়েবলের নামের সামনে mut যোগ করে সেগুলিকে পরিবর্তনযোগ্য করতে পারেন। mut যোগ করা কোডের ভবিষ্যতের পাঠকদের কাছেও উদ্দেশ্য প্রকাশ করে, এটা নির্দেশ করে যে কোডের অন্যান্য অংশ এই ভ্যারিয়েবলের মান পরিবর্তন করবে।

উদাহরণস্বরূপ, চলুন src/main.rs পরিবর্তন করে নিম্নলিখিতটি করা যাক:

ফাইলের নাম: src/main.rs

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

যখন আমরা এখন প্রোগ্রামটি চালাই, আমরা এটি পাই:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

যখন mut ব্যবহার করা হয়, তখন আমরা x-এর সাথে বাইন্ড করা মান 5 থেকে 6-এ পরিবর্তন করার অনুমতি পাই। পরিশেষে, পরিবর্তনশীলতা ব্যবহার করবেন কি না, তা আপনার উপর নির্ভর করে এবং সেই নির্দিষ্ট পরিস্থিতিতে কোনটি সবচেয়ে স্পষ্ট বলে আপনি মনে করেন তার উপর নির্ভর করে।

কনস্ট্যান্ট (Constants)

অপরিবর্তনীয় ভ্যারিয়েবলের মতো, কনস্ট্যান্ট হলো এমন মান যা একটি নামের সাথে বাইন্ড করা থাকে এবং পরিবর্তন করার অনুমতি নেই, তবে কনস্ট্যান্ট এবং ভ্যারিয়েবলের মধ্যে কয়েকটি পার্থক্য রয়েছে।

প্রথমত, আপনাকে কনস্ট্যান্টের সাথে mut ব্যবহার করার অনুমতি নেই। কনস্ট্যান্ট শুধু ডিফল্টরূপে অপরিবর্তনীয় নয়—তারা সবসময়ই অপরিবর্তনীয়। আপনি let কীওয়ার্ডের পরিবর্তে const কীওয়ার্ড ব্যবহার করে কনস্ট্যান্ট ঘোষণা করেন, এবং মানের টাইপ অবশ্যই অ্যানোটেট করতে হবে। আমরা পরবর্তী বিভাগে, "ডেটা টাইপ"-এ, টাইপ এবং টাইপ অ্যানোটেশন নিয়ে আলোচনা করব, তাই এখনই বিস্তারিত নিয়ে চিন্তা করবেন না। শুধু জেনে রাখুন যে আপনাকে সবসময় টাইপ অ্যানোটেট করতে হবে।

কনস্ট্যান্ট যেকোনো স্কোপে, এমনকি গ্লোবাল স্কোপেও ঘোষণা করা যেতে পারে, যা তাদের সেইসব মানের জন্য দরকারী করে তোলে যা কোডের অনেক অংশের জানা প্রয়োজন।

শেষ পার্থক্য হল যে কনস্ট্যান্ট শুধুমাত্র একটি কনস্ট্যান্ট এক্সপ্রেশনে সেট করা যেতে পারে, এমন কোনো মানের ফলাফলে নয় যা কেবল রানটাইমে গণনা করা যেতে পারে।

এখানে একটি কনস্ট্যান্ট ঘোষণার উদাহরণ:

#![allow(unused)]
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

কনস্ট্যান্টের নাম THREE_HOURS_IN_SECONDS এবং এর মান 60 (এক মিনিটে সেকেন্ডের সংখ্যা) কে 60 (এক ঘন্টায় মিনিটের সংখ্যা) দিয়ে এবং তারপর 3 (এই প্রোগ্রামে আমরা যত ঘন্টা গণনা করতে চাই) দিয়ে গুণ করার ফলাফলে সেট করা হয়েছে। কনস্ট্যান্টের জন্য রাস্টের নামকরণের প্রথা হল সব বড় হাতের অক্ষর ব্যবহার করা এবং শব্দগুলোর মধ্যে আন্ডারস্কোর ব্যবহার করা। কম্পাইলার কম্পাইল করার সময় একটি সীমিত সেট অপারেশন মূল্যায়ন করতে সক্ষম, যা আমাদের এই মানটিকে এমনভাবে লেখার সুযোগ দেয় যা বোঝা এবং যাচাই করা সহজ, এই কনস্ট্যান্টটিকে 10,800 মানে সেট করার পরিবর্তে। কনস্ট্যান্ট ঘোষণা করার সময় কোন অপারেশনগুলো ব্যবহার করা যেতে পারে সে সম্পর্কে আরও তথ্যের জন্য রাস্ট রেফারেন্সের কনস্ট্যান্ট মূল্যায়ন সম্পর্কিত বিভাগ দেখুন।

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

আপনার প্রোগ্রাম জুড়ে ব্যবহৃত হার্ডকোডেড মানগুলোকে কনস্ট্যান্ট হিসাবে নামকরণ করা কোডের ভবিষ্যতের রক্ষণাবেক্ষণকারীদের কাছে সেই মানের অর্থ বোঝাতে দরকারী। এটি আপনার কোডে কেবল একটি জায়গা রাখতেও সাহায্য করে যা ভবিষ্যতে হার্ডকোডেড মান আপডেট করার প্রয়োজন হলে পরিবর্তন করতে হবে।

শ্যাডোইং (Shadowing)

যেমন আপনি অধ্যায় ২-এর গেসিং গেম টিউটোরিয়ালে দেখেছেন, আপনি একটি পূর্ববর্তী ভ্যারিয়েবলের একই নামে একটি নতুন ভ্যারিয়েবল ঘোষণা করতে পারেন। রাস্টেশিয়ানরা বলেন যে প্রথম ভ্যারিয়েবলটি দ্বিতীয়টি দ্বারা শ্যাডো (shadowed) করা হয়েছে, যার মানে হল যে দ্বিতীয় ভ্যারিয়েবলটি হল যা কম্পাইলার দেখবে যখন আপনি ভ্যারিয়েবলের নামটি ব্যবহার করবেন। কার্যকরভাবে, দ্বিতীয় ভ্যারিয়েবলটি প্রথমটিকে ছাপিয়ে যায়, ভ্যারিয়েবলের নামের যেকোনো ব্যবহার নিজের দিকে নিয়ে নেয় যতক্ষণ না এটি নিজে শ্যাডো করা হয় বা স্কোপ শেষ হয়। আমরা একই ভ্যারিয়েবলের নাম ব্যবহার করে এবং let কীওয়ার্ডের ব্যবহার পুনরাবৃত্তি করে একটি ভ্যারিয়েবলকে শ্যাডো করতে পারি, যেমনটি নিচে দেওয়া হল:

ফাইলের নাম: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

এই প্রোগ্রামটি প্রথমে x-কে 5 মানের সাথে বাইন্ড করে। তারপরে এটি let x = পুনরাবৃত্তি করে একটি নতুন ভ্যারিয়েবল x তৈরি করে, মূল মানটি নিয়ে এবং 1 যোগ করে যাতে x-এর মান তখন 6 হয়। তারপর, কার্লি ব্র্যাকেট দিয়ে তৈরি একটি অভ্যন্তরীণ স্কোপের মধ্যে, তৃতীয় let স্টেটমেন্টটিও x-কে শ্যাডো করে এবং একটি নতুন ভ্যারিয়েবল তৈরি করে, পূর্ববর্তী মানকে 2 দিয়ে গুণ করে x-কে 12 মান দেয়। যখন সেই স্কোপ শেষ হয়ে যায়, তখন অভ্যন্তরীণ শ্যাডোইং শেষ হয় এবং x আবার 6-এ ফিরে আসে। যখন আমরা এই প্রোগ্রামটি চালাই, তখন এটি নিম্নলিখিত আউটপুট দেবে:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

শ্যাডোইং একটি ভ্যারিয়েবলকে mut হিসাবে চিহ্নিত করার থেকে ভিন্ন কারণ আমরা যদি let কীওয়ার্ড ব্যবহার না করে ভুলবশত এই ভ্যারিয়েবলে পুনরায় অ্যাসাইন করার চেষ্টা করি তবে আমরা একটি কম্পাইল-টাইম এরর পাব। let ব্যবহার করে, আমরা একটি মানের উপর কয়েকটি রূপান্তর করতে পারি কিন্তু সেই রূপান্তরগুলো সম্পন্ন হওয়ার পরে ভ্যারিয়েবলটি অপরিবর্তনীয় থাকে।

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

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

প্রথম spaces ভ্যারিয়েবলটি একটি স্ট্রিং টাইপ এবং দ্বিতীয় spaces ভ্যারিয়েবলটি একটি সংখ্যা টাইপ। শ্যাডোইং এইভাবে আমাদের spaces_str এবং spaces_num এর মতো বিভিন্ন নাম নিয়ে আসা থেকে বাঁচায়; পরিবর্তে, আমরা সহজ spaces নামটি পুনরায় ব্যবহার করতে পারি। তবে, আমরা যদি এর জন্য mut ব্যবহার করার চেষ্টা করি, যেমনটি এখানে দেখানো হয়েছে, আমরা একটি কম্পাইল-টাইম এরর পাব:

fn main() {
    let mut spaces = "   ";
    spaces = spaces.len();
}

এররটি বলছে যে আমাদের একটি ভ্যারিয়েবলের টাইপ মিউটেট করার অনুমতি নেই:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` (bin "variables") due to 1 previous error

এখন আমরা ভ্যারিয়েবলগুলো কীভাবে কাজ করে তা অন্বেষণ করেছি, চলুন দেখা যাক তাদের আর কী কী ডেটা টাইপ থাকতে পারে।

ডেটা টাইপ

রাস্ট-এর প্রতিটি ভ্যালুর একটি নির্দিষ্ট ডেটা টাইপ থাকে, যা রাস্টকে বলে দেয় কী ধরনের ডেটা নির্দিষ্ট করা হচ্ছে যাতে এটি সেই ডেটার সাথে কীভাবে কাজ করতে হবে তা জানতে পারে। আমরা দুটি ডেটা টাইপের উপসেট দেখব: স্কেলার (scalar) এবং কম্পাউন্ড (compound)।

মনে রাখবেন যে রাস্ট একটি স্ট্যাটিক্যালি টাইপড ল্যাঙ্গুয়েজ, যার মানে হল কম্পাইল করার সময় এটিকে অবশ্যই সমস্ত ভ্যারিয়েবলের টাইপ জানতে হবে। কম্পাইলার সাধারণত আমরা কোন টাইপ ব্যবহার করতে চাই তা ভ্যালু এবং আমরা কীভাবে এটি ব্যবহার করি তার উপর ভিত্তি করে অনুমান করতে পারে। যখন অনেকগুলো টাইপ সম্ভব হয়, যেমন অধ্যায় ২-এর "অনুমানের সাথে গোপন সংখ্যার তুলনা" বিভাগে আমরা যখন parse ব্যবহার করে একটি String-কে একটি নিউমেরিক টাইপে রূপান্তর করেছিলাম, তখন আমাদের অবশ্যই একটি টাইপ অ্যানোটেশন যোগ করতে হবে, যেমন:

#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}

যদি আমরা উপরের কোডে দেখানো : u32 টাইপ অ্যানোটেশন যোগ না করি, রাস্ট নিম্নলিখিত এররটি প্রদর্শন করবে, যার মানে হল আমরা কোন টাইপ ব্যবহার করতে চাই তা জানার জন্য কম্পাইলারের আমাদের কাছ থেকে আরও তথ্য প্রয়োজন:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `guess` an explicit type
  |
2 |     let guess: /* Type */ = "42".parse().expect("Not a number!");
  |              ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

আপনি অন্যান্য ডেটা টাইপের জন্য বিভিন্ন টাইপ অ্যানোটেশন দেখতে পাবেন।

স্কেলার টাইপ (Scalar Types)

একটি স্কেলার টাইপ একটি একক মান উপস্থাপন করে। রাস্টের চারটি প্রাথমিক স্কেলার টাইপ রয়েছে: ইন্টিজার (integers), ফ্লোটিং-পয়েন্ট নাম্বার (floating-point numbers), বুলিয়ান (Booleans) এবং ক্যারেক্টার (characters)। আপনি হয়তো অন্যান্য প্রোগ্রামিং ল্যাঙ্গুয়েজ থেকে এগুলোর সাথে পরিচিত। চলুন রাস্ট-এ এগুলো কীভাবে কাজ করে তা দেখা যাক।

ইন্টিজার টাইপ (Integer Types)

একটি ইন্টিজার হল একটি সংখ্যা যার কোনো ভগ্নাংশ নেই। আমরা অধ্যায় ২-এ একটি ইন্টিজার টাইপ, u32 টাইপ ব্যবহার করেছি। এই টাইপ ডিক্লারেশনটি নির্দেশ করে যে এর সাথে যুক্ত ভ্যালুটি একটি আনসাইন্ড ইন্টিজার (সাইনড ইন্টিজার টাইপগুলো u এর পরিবর্তে i দিয়ে শুরু হয়) যা ৩২ বিট জায়গা নেয়। সারণী ৩-১ রাস্টের বিল্ট-ইন ইন্টিজার টাইপগুলো দেখায়। আমরা একটি ইন্টিজার ভ্যালুর টাইপ ঘোষণা করতে এই ভ্যারিয়েন্টগুলোর যেকোনো একটি ব্যবহার করতে পারি।

সারণী ৩-১: রাস্ট-এ ইন্টিজার টাইপ

প্রতিটি ভ্যারিয়েন্ট সাইনড বা আনসাইনড হতে পারে এবং এর একটি সুস্পষ্ট আকার রয়েছে। সাইনড এবং আনসাইনড বলতে বোঝায় যে সংখ্যাটি ঋণাত্মক হওয়া সম্ভব কিনা—অন্য কথায়, সংখ্যাটির সাথে একটি চিহ্ন (সাইন) থাকার প্রয়োজন আছে কিনা (সাইনড) অথবা এটি কেবল ধনাত্মক হবে এবং তাই কোনো চিহ্ন ছাড়াই উপস্থাপন করা যেতে পারে (আনসাইনড)। এটা কাগজে সংখ্যা লেখার মতো: যখন চিহ্ন গুরুত্বপূর্ণ, তখন একটি সংখ্যা প্লাস বা মাইনাস চিহ্ন দিয়ে দেখানো হয়; তবে, যখন সংখ্যাটি ধনাত্মক বলে ধরে নেওয়া নিরাপদ, তখন এটি কোনো চিহ্ন ছাড়াই দেখানো হয়। সাইনড সংখ্যা two’s complement রিপ্রেজেন্টেশন ব্যবহার করে সংরক্ষণ করা হয়।

প্রতিটি সাইনড ভ্যারিয়েন্ট −(২^{n − ১}) থেকে ২^{n − ১} − ১ পর্যন্ত সংখ্যা সংরক্ষণ করতে পারে, যেখানে n হল সেই ভ্যারিয়েন্টটি যে বিট সংখ্যা ব্যবহার করে। তাই একটি i8 −(২^৭) থেকে ২^৭ − ১ পর্যন্ত, যা −১২৮ থেকে ১২৭ এর সমান, সংখ্যা সংরক্ষণ করতে পারে। আনসাইনড ভ্যারিয়েন্টগুলো ০ থেকে ২ⁿ − ১ পর্যন্ত সংখ্যা সংরক্ষণ করতে পারে, তাই একটি u8 ০ থেকে ২^৮ − ১ পর্যন্ত, যা ০ থেকে ২৫৫ এর সমান, সংখ্যা সংরক্ষণ করতে পারে।

এছাড়াও, isize এবং usize টাইপগুলো আপনার প্রোগ্রাম যে কম্পিউটারের আর্কিটেকচারে চলছে তার উপর নির্ভর করে: ৬৪-বিট আর্কিটেকচারে থাকলে ৬৪ বিট এবং ৩২-বিট আর্কিটেকচারে থাকলে ৩২ বিট।

আপনি সারণী ৩-২-এ দেখানো যেকোনো ফর্মে ইন্টিজার লিটারেল লিখতে পারেন। মনে রাখবেন যে যেসব নাম্বার লিটারেল একাধিক নিউমেরিক টাইপ হতে পারে, সেগুলোতে টাইপ নির্দিষ্ট করার জন্য একটি টাইপ সাফিক্স, যেমন 57u8, অনুমোদিত। নাম্বার লিটারেলগুলোতে সংখ্যাটি সহজে পড়ার জন্য একটি ভিজ্যুয়াল সেপারেটর হিসাবে _ ব্যবহার করা যেতে পারে, যেমন 1_000, যার মান 1000 নির্দিষ্ট করার মতোই হবে।

সারণী ৩-২: রাস্ট-এ ইন্টিজার লিটারেল

তাহলে আপনি কীভাবে জানবেন কোন ধরনের ইন্টিজার ব্যবহার করবেন? আপনি যদি অনিশ্চিত হন, রাস্টের ডিফল্টগুলো সাধারণত শুরু করার জন্য ভাল জায়গা: ইন্টিজার টাইপগুলো ডিফল্টভাবে i32 হয়। isize বা usize ব্যবহার করার প্রাথমিক পরিস্থিতি হল কোনো ধরনের কালেকশন ইনডেক্স করার সময়।

ইন্টিজার ওভারফ্লো (Integer Overflow)

ধরা যাক আপনার কাছে u8 টাইপের একটি ভ্যারিয়েবল আছে যা ০ থেকে ২৫৫ এর মধ্যে মান ধারণ করতে পারে। আপনি যদি ভ্যারিয়েবলটিকে সেই পরিসরের বাইরের কোনো মানে পরিবর্তন করার চেষ্টা করেন, যেমন ২৫৬, তাহলে ইন্টিজার ওভারফ্লো ঘটবে, যা দুটি আচরণের একটির কারণ হতে পারে। আপনি যখন ডিবাগ মোডে কম্পাইল করছেন, তখন রাস্ট ইন্টিজার ওভারফ্লোর জন্য চেক অন্তর্ভুক্ত করে যা এই আচরণ ঘটলে আপনার প্রোগ্রামকে রানটাইমে প্যানিক (panic) করায়। রাস্ট প্যানিকিং শব্দটি ব্যবহার করে যখন একটি প্রোগ্রাম একটি এরর সহ বন্ধ হয়ে যায়; আমরা অধ্যায় ৯-এর "Unrecoverable Errors with panic!" বিভাগে প্যানিক নিয়ে আরও गहराई से আলোচনা করব।

আপনি যখন --release ফ্ল্যাগ দিয়ে রিলিজ মোডে কম্পাইল করছেন, তখন রাস্ট প্যানিক সৃষ্টিকারী ইন্টিজার ওভারফ্লোর জন্য চেক অন্তর্ভুক্ত করে না। পরিবর্তে, যদি ওভারফ্লো ঘটে, রাস্ট টু'স কমপ্লিমেন্ট র‍্যাপিং (two’s complement wrapping) করে। সংক্ষেপে, টাইপটি যে সর্বোচ্চ মান ধারণ করতে পারে তার চেয়ে বড় মানগুলো "র‍্যাপ অ্যারাউন্ড" করে টাইপটি যে সর্বনিম্ন মান ধারণ করতে পারে সেখানে চলে আসে। একটি u8-এর ক্ষেত্রে, মান ২৫৬ হয়ে যায় ০, মান ২৫৭ হয়ে যায় ১, এবং এভাবেই চলতে থাকে। প্রোগ্রামটি প্যানিক করবে না, কিন্তু ভ্যারিয়েবলটির একটি এমন মান থাকবে যা সম্ভবত আপনি যা আশা করেছিলেন তা নয়। ইন্টিজার ওভারফ্লোর র‍্যাপিং আচরণের উপর নির্ভর করা একটি এরর হিসাবে বিবেচিত হয়।

ওভারফ্লোর সম্ভাবনা স্পষ্টভাবে পরিচালনা করার জন্য, আপনি প্রিমিটিভ নিউমেরিক টাইপগুলোর জন্য স্ট্যান্ডার্ড লাইব্রেরি দ্বারা প্রদত্ত এই মেথডগুলোর পরিবার ব্যবহার করতে পারেন:

• wrapping_* মেথড, যেমন wrapping_add, দিয়ে সমস্ত মোডে র‍্যাপ করুন।
• checked_* মেথড দিয়ে ওভারফ্লো হলে None মান প্রদান করুন।
• overflowing_* মেথড দিয়ে মান এবং একটি বুলিয়ান যা নির্দেশ করে ওভারফ্লো হয়েছে কিনা তা প্রদান করুন।
• saturating_* মেথড দিয়ে মানের সর্বনিম্ন বা সর্বোচ্চ মানে স্যাচুরেট করুন।

ফ্লোটিং-পয়েন্ট টাইপ (Floating-Point Types)

রাস্ট-এ ফ্লোটিং-পয়েন্ট নাম্বার, যা দশমিক বিন্দুযুক্ত সংখ্যা, এর জন্য দুটি প্রিমিটিভ টাইপও রয়েছে। রাস্টের ফ্লোটিং-পয়েন্ট টাইপগুলো হল f32 এবং f64, যা যথাক্রমে ৩২ বিট এবং ৬৪ বিট আকারের। ডিফল্ট টাইপ হল f64 কারণ আধুনিক সিপিইউগুলিতে, এটি f32-এর মতো প্রায় একই গতির কিন্তু আরও বেশি নির্ভুলতা (precision) দিতে সক্ষম। সমস্ত ফ্লোটিং-পয়েন্ট টাইপ সাইনড।

এখানে একটি উদাহরণ যা ফ্লোটিং-পয়েন্ট নাম্বারগুলোকে কার্যকর অবস্থায় দেখায়:

ফাইলের নাম: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

ফ্লোটিং-পয়েন্ট নাম্বারগুলো IEEE-754 স্ট্যান্ডার্ড অনুযায়ী উপস্থাপিত হয়।

নিউমেরিক অপারেশনস (Numeric Operations)

রাস্ট সমস্ত নাম্বার টাইপের জন্য আপনার প্রত্যাশিত মৌলিক গাণিতিক অপারেশনগুলো সমর্থন করে: যোগ, বিয়োগ, গুণ, ভাগ এবং ভাগশেষ (remainder)। ইন্টিজার ডিভিশন নিকটতম পূর্ণসংখ্যার দিকে শূন্যের দিকে ছেঁটে (truncates) ফেলে। নিম্নলিখিত কোডটি দেখায় যে আপনি কীভাবে একটি let স্টেটমেন্টে প্রতিটি নিউমেরিক অপারেশন ব্যবহার করবেন:

ফাইলের নাম: src/main.rs

fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // Results in -1

    // remainder
    let remainder = 43 % 5;
}

এই স্টেটমেন্টগুলোর প্রতিটি এক্সপ্রেশন একটি গাণিতিক অপারেটর ব্যবহার করে এবং একটি একক মানে মূল্যায়ন করে, যা তারপর একটি ভ্যারিয়েবলের সাথে বাইন্ড করা হয়। পরিশিষ্ট বি তে রাস্ট দ্বারা প্রদত্ত সমস্ত অপারেটরের একটি তালিকা রয়েছে।

বুলিয়ান টাইপ (The Boolean Type)

অন্যান্য বেশিরভাগ প্রোগ্রামিং ল্যাঙ্গুয়েজের মতোই, রাস্ট-এ একটি বুলিয়ান টাইপের দুটি সম্ভাব্য মান রয়েছে: true এবং false। বুলিয়ানগুলো এক বাইট আকারের। রাস্ট-এ বুলিয়ান টাইপ bool ব্যবহার করে নির্দিষ্ট করা হয়। উদাহরণস্বরূপ:

ফাইলের নাম: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

বুলিয়ান মান ব্যবহার করার প্রধান উপায় হল কন্ডিশনাল, যেমন একটি if এক্সপ্রেশন। আমরা "কন্ট্রোল ফ্লো" বিভাগে রাস্ট-এ if এক্সপ্রেশন কীভাবে কাজ করে তা কভার করব।

ক্যারেক্টার টাইপ (The Character Type)

রাস্টের char টাইপ হল ভাষার সবচেয়ে আদিম বর্ণানুক্রমিক টাইপ। এখানে char মান ঘোষণা করার কিছু উদাহরণ দেওয়া হল:

ফাইলের নাম: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

লক্ষ্য করুন যে আমরা char লিটারেলগুলোকে একক উদ্ধৃতি (single quotes) দিয়ে নির্দিষ্ট করি, স্ট্রিং লিটারেলের বিপরীতে, যা দ্বৈত উদ্ধৃতি (double quotes) ব্যবহার করে। রাস্টের char টাইপ চার বাইট আকারের এবং একটি ইউনিকোড স্কেলার মান (Unicode Scalar Value) উপস্থাপন করে, যার মানে এটি শুধু ASCII-এর চেয়ে অনেক বেশি কিছু উপস্থাপন করতে পারে। অ্যাকসেন্টেড অক্ষর; চীনা, জাপানি এবং কোরিয়ান অক্ষর; ইমোজি; এবং শূন্য-প্রস্থের স্পেস সবই রাস্ট-এ বৈধ char মান। ইউনিকোড স্কেলার মান U+0000 থেকে U+D7FF এবং U+E000 থেকে U+10FFFF পর্যন্ত অন্তর্ভুক্ত। তবে, ইউনিকোডে "ক্যারেক্টার" realmente একটি ধারণা নয়, তাই "ক্যারেক্টার" বলতে আপনার মানবিক অনুভূতি রাস্ট-এ একটি char যা তার সাথে নাও মিলতে পারে। আমরা এই বিষয়টি অধ্যায় ৮-এর "Storing UTF-8 Encoded Text with Strings" বিভাগে বিস্তারিতভাবে আলোচনা করব।

কম্পাউন্ড টাইপ (Compound Types)

কম্পাউন্ড টাইপ একাধিক মানকে একটি টাইপে গ্রুপ করতে পারে। রাস্টের দুটি প্রিমিটিভ কম্পাউন্ড টাইপ রয়েছে: টাপল (tuples) এবং অ্যারে (arrays)।

টাপল টাইপ (The Tuple Type)

একটি টাপল হল বিভিন্ন টাইপের একাধিক মানকে একটি কম্পাউন্ড টাইপে একত্রিত করার একটি সাধারণ উপায়। টাপলগুলোর একটি নির্দিষ্ট দৈর্ঘ্য থাকে: একবার ঘোষণা করা হলে, তারা আকারে বাড়তে বা কমতে পারে না।

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

ফাইলের নাম: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

tup ভ্যারিয়েবলটি পুরো টাপলের সাথে বাইন্ড করে কারণ একটি টাপলকে একটি একক কম্পাউন্ড উপাদান হিসাবে বিবেচনা করা হয়। একটি টাপল থেকে পৃথক মানগুলো পেতে, আমরা প্যাটার্ন ম্যাচিং ব্যবহার করে একটি টাপল মানকে ডিস্ট্রাকচার (destructure) করতে পারি, এভাবে:

ফাইলের নাম: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

এই প্রোগ্রামটি প্রথমে একটি টাপল তৈরি করে এবং এটিকে tup ভ্যারিয়েবলের সাথে বাইন্ড করে। তারপরে এটি let এর সাথে একটি প্যাটার্ন ব্যবহার করে tup কে নিয়ে তিনটি পৃথক ভ্যারিয়েবল, x, y, এবং z তে পরিণত করে। একে ডিস্ট্রাকচারিং বলা হয় কারণ এটি একক টাপলকে তিনটি অংশে ভেঙে দেয়। অবশেষে, প্রোগ্রামটি y-এর মান প্রিন্ট করে, যা 6.4।

আমরা একটি পিরিয়ড (.) এবং তারপরে আমরা যে মানটি অ্যাক্সেস করতে চাই তার ইনডেক্স ব্যবহার করে সরাসরি একটি টাপল উপাদান অ্যাক্সেস করতে পারি। উদাহরণস্বরূপ:

ফাইলের নাম: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

এই প্রোগ্রামটি x টাপল তৈরি করে এবং তারপরে তাদের নিজ নিজ ইনডেক্স ব্যবহার করে টাপলের প্রতিটি উপাদান অ্যাক্সেস করে। বেশিরভাগ প্রোগ্রামিং ল্যাঙ্গুয়েজের মতোই, একটি টাপলের প্রথম ইনডেক্স হল ০।

কোনো মান ছাড়াই টাপলটির একটি বিশেষ নাম আছে, ইউনিট। এই মান এবং এর সংশ্লিষ্ট টাইপ উভয়ই () লেখা হয় এবং একটি খালি মান বা একটি খালি রিটার্ন টাইপ উপস্থাপন করে। এক্সপ্রেশনগুলো যদি অন্য কোনো মান রিটার্ন না করে তবে তারা অন্তর্নিহিতভাবে ইউনিট মান রিটার্ন করে।

অ্যারে টাইপ (The Array Type)

একাধিক মানের একটি সংগ্রহ থাকার আরেকটি উপায় হল একটি অ্যারে। একটি টাপলের বিপরীতে, একটি অ্যারের প্রতিটি উপাদানের একই টাইপ থাকতে হবে। অন্য কিছু ভাষার অ্যারের বিপরীতে, রাস্ট-এ অ্যারেগুলোর একটি নির্দিষ্ট দৈর্ঘ্য থাকে।

আমরা একটি অ্যারের মানগুলো বর্গাকার বন্ধনীর ভিতরে কমা দ্বারা পৃথক করা তালিকা হিসাবে লিখি:

ফাইলের নাম: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

অ্যারেগুলো দরকারী যখন আপনি চান আপনার ডেটা স্ট্যাকে (stack) বরাদ্দ করা হোক, যেমন আমরা এখন পর্যন্ত দেখেছি অন্যান্য টাইপের মতো, হিপের (heap) পরিবর্তে (আমরা অধ্যায় ৪-এ স্ট্যাক এবং হিপ নিয়ে আরও আলোচনা করব) অথবা যখন আপনি নিশ্চিত করতে চান যে আপনার কাছে সর্বদা একটি নির্দিষ্ট সংখ্যক উপাদান রয়েছে। একটি অ্যারে ভেক্টর টাইপের মতো নমনীয় নয়। একটি ভেক্টর হল স্ট্যান্ডার্ড লাইব্রেরি দ্বারা প্রদত্ত একটি অনুরূপ সংগ্রহ টাইপ যা আকারে বাড়তে বা কমতে পারে কারণ এর বিষয়বস্তু হিপে থাকে। আপনি যদি অ্যারে বা ভেক্টর ব্যবহার করবেন কিনা তা নিয়ে অনিশ্চিত হন, তবে সম্ভাবনা হল আপনার একটি ভেক্টর ব্যবহার করা উচিত। অধ্যায় ৮ ভেক্টর নিয়ে আরও বিস্তারিত আলোচনা করে।

তবে, অ্যারেগুলো আরও বেশি দরকারী যখন আপনি জানেন যে উপাদানের সংখ্যা পরিবর্তন করার প্রয়োজন হবে না। উদাহরণস্বরূপ, আপনি যদি একটি প্রোগ্রামে মাসের নাম ব্যবহার করেন, তবে আপনি সম্ভবত একটি ভেক্টরর পরিবর্তে একটি অ্যারে ব্যবহার করবেন কারণ আপনি জানেন যে এটিতে সর্বদা ১২টি উপাদান থাকবে:

#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
}

আপনি একটি অ্যারের টাইপ বর্গাকার বন্ধনী ব্যবহার করে প্রতিটি উপাদানের টাইপ, একটি সেমিকোলন এবং তারপরে অ্যারের উপাদানের সংখ্যা দিয়ে লিখেন, এভাবে:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

এখানে, i32 প্রতিটি উপাদানের টাইপ। সেমিকোলনের পরে, 5 সংখ্যাটি নির্দেশ করে যে অ্যারেটিতে পাঁচটি উপাদান রয়েছে।

আপনি প্রতিটি উপাদানের জন্য একই মান ধারণ করার জন্য একটি অ্যারে ইনিশিয়ালাইজ করতে পারেন, প্রাথমিক মান নির্দিষ্ট করে, তারপর একটি সেমিকোলন, এবং তারপর বর্গাকার বন্ধনীতে অ্যারের দৈর্ঘ্য, যেমনটি এখানে দেখানো হয়েছে:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

a নামের অ্যারেটিতে 5 টি উপাদান থাকবে যা সব প্রাথমিকভাবে 3 মানে সেট করা হবে। এটি let a = [3, 3, 3, 3, 3]; লেখার মতোই কিন্তু আরও সংক্ষিপ্ত উপায়ে।

অ্যারে উপাদান অ্যাক্সেস করা

একটি অ্যারে হল একটি পরিচিত, নির্দিষ্ট আকারের মেমরির একক খণ্ড যা স্ট্যাকে বরাদ্দ করা যেতে পারে। আপনি ইনডেক্সিং ব্যবহার করে একটি অ্যারের উপাদান অ্যাক্সেস করতে পারেন, এভাবে:

ফাইলের নাম: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

এই উদাহরণে, first নামের ভ্যারিয়েবলটি 1 মান পাবে কারণ এটি অ্যারের [0] ইনডেক্সে থাকা মান। second নামের ভ্যারিয়েবলটি অ্যারের [1] ইনডেক্স থেকে 2 মান পাবে।

অবৈধ অ্যারে উপাদান অ্যাক্সেস

চলুন দেখি আপনি যদি একটি অ্যারের শেষ প্রান্তের বাইরের কোনো উপাদান অ্যাক্সেস করার চেষ্টা করেন তবে কী ঘটে। ধরা যাক আপনি অধ্যায় ২-এর অনুমান করার গেমের মতো এই কোডটি চালান, ব্যবহারকারীর কাছ থেকে একটি অ্যারে ইনডেক্স পেতে:

ফাইলের নাম: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Please enter an array index.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Failed to read line");

    let index: usize = index
        .trim()
        .parse()
        .expect("Index entered was not a number");

    let element = a[index];

    println!("The value of the element at index {index} is: {element}");
}

এই কোডটি সফলভাবে কম্পাইল হয়। আপনি যদি cargo run ব্যবহার করে এই কোডটি চালান এবং 0, 1, 2, 3, বা 4 প্রবেশ করান, প্রোগ্রামটি অ্যারের সেই ইনডেক্সে থাকা সংশ্লিষ্ট মানটি প্রিন্ট করবে। আপনি যদি পরিবর্তে অ্যারের শেষের বাইরের কোনো সংখ্যা প্রবেশ করান, যেমন 10, আপনি এই ধরনের আউটপুট দেখতে পাবেন:

thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

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

এটি রাস্টের মেমরি সেফটি নীতির একটি উদাহরণ। অনেক নিম্ন-স্তরের ভাষায়, এই ধরনের পরীক্ষা করা হয় না, এবং যখন আপনি একটি ভুল ইনডেক্স প্রদান করেন, তখন অবৈধ মেমরি অ্যাক্সেস করা হতে পারে। রাস্ট আপনাকে এই ধরনের ত্রুটির বিরুদ্ধে সুরক্ষা দেয়, মেমরি অ্যাক্সেসের অনুমতি দিয়ে এবং চালিয়ে যাওয়ার পরিবর্তে অবিলম্বে প্রস্থান করে। অধ্যায় ৯ রাস্টের এরর হ্যান্ডলিং সম্পর্কে আরও আলোচনা করে এবং কীভাবে আপনি পঠনযোগ্য, নিরাপদ কোড লিখতে পারেন যা প্যানিকও করে না বা অবৈধ মেমরি অ্যাক্সেসের অনুমতিও দেয় না।

ফাংশন (Functions)

রাস্ট কোডে ফাংশনের ব্যাপক ব্যবহার দেখা যায়। আপনি ইতিমধ্যে ভাষার সবচেয়ে গুরুত্বপূর্ণ ফাংশনগুলোর মধ্যে একটি দেখেছেন: main ফাংশন, যা অনেক প্রোগ্রামের প্রবেশ বিন্দু (entry point)। আপনি fn কীওয়ার্ডও দেখেছেন, যা আপনাকে নতুন ফাংশন ঘোষণা করার সুযোগ দেয়।

রাস্ট কোড ফাংশন এবং ভ্যারিয়েবলের নামের জন্য প্রচলিত শৈলী হিসাবে স্নেক কেস (snake case) ব্যবহার করে, যেখানে সমস্ত অক্ষর ছোট হাতের হয় এবং শব্দগুলোকে আন্ডারস্কোর দিয়ে আলাদা করা হয়। এখানে একটি প্রোগ্রাম রয়েছে যাতে একটি উদাহরণ ফাংশন সংজ্ঞা রয়েছে:

ফাইলের নাম: src/main.rs

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

আমরা রাস্ট-এ একটি ফাংশন সংজ্ঞায়িত করি fn লিখে, তারপরে ফাংশনের নাম এবং একজোড়া প্রথম বন্ধনী। কোঁকড়া বন্ধনী (curly brackets) কম্পাইলারকে বলে দেয় যে ফাংশন বডি কোথায় শুরু এবং শেষ হয়েছে।

আমরা আমাদের সংজ্ঞায়িত যেকোনো ফাংশনকে তার নাম এবং তারপরে একজোড়া প্রথম বন্ধনী লিখে কল করতে পারি। যেহেতু another_function প্রোগ্রামে সংজ্ঞায়িত করা হয়েছে, তাই এটি main ফাংশনের ভিতর থেকে কল করা যেতে পারে। লক্ষ্য করুন যে আমরা সোর্স কোডে main ফাংশনের পরে another_function সংজ্ঞায়িত করেছি; আমরা এটি আগেও সংজ্ঞায়িত করতে পারতাম। রাস্ট আপনার ফাংশনগুলো কোথায় সংজ্ঞায়িত করা হয়েছে তা নিয়ে চিন্তা করে না, কেবল এটি দেখে যে সেগুলো কলারের দ্বারা দেখা যায় এমন একটি স্কোপে সংজ্ঞায়িত করা হয়েছে কিনা।

চলুন ফাংশন সম্পর্কে আরও অন্বেষণ করতে functions নামে একটি নতুন বাইনারি প্রজেক্ট শুরু করি। src/main.rs ফাইলে another_function উদাহরণটি রাখুন এবং এটি চালান। আপনার নিম্নলিখিত আউটপুট দেখতে পাওয়া উচিত:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/functions`
Hello, world!
Another function.

লাইনগুলো main ফাংশনে যেভাবে প্রদর্শিত হয়েছে সেই ক্রমে কার্যকর হয়। প্রথমে "Hello, world!" বার্তাটি প্রিন্ট হয়, এবং তারপর another_function কল করা হয় এবং এর বার্তাটি প্রিন্ট হয়।

প্যারামিটার (Parameters)

আমরা ফাংশনগুলোকে প্যারামিটার (parameters) সহ সংজ্ঞায়িত করতে পারি, যা ফাংশনের সিগনেচারের অংশ হিসাবে বিশেষ ভ্যারিয়েবল। যখন একটি ফাংশনে প্যারামিটার থাকে, আপনি সেই প্যারামিটারগুলোর জন্য এটিকে নির্দিষ্ট মান (concrete values) সরবরাহ করতে পারেন। প্রযুক্তিগতভাবে, নির্দিষ্ট মানগুলোকে আর্গুমেন্ট (arguments) বলা হয়, কিন্তু সাধারণ কথোপকথনে, লোকেরা প্যারামিটার এবং আর্গুমেন্ট শব্দ দুটিকে ফাংশনের সংজ্ঞায় ভ্যারিয়েবল বা ফাংশন কল করার সময় পাস করা নির্দিষ্ট মানগুলোর জন্য अदলবদল করে ব্যবহার করে।

another_function-এর এই সংস্করণে আমরা একটি প্যারামিটার যোগ করি:

ফাইলের নাম: src/main.rs

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {x}");
}

এই প্রোগ্রামটি চালানোর চেষ্টা করুন; আপনার নিম্নলিখিত আউটপুট পাওয়া উচিত:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.21s
     Running `target/debug/functions`
The value of x is: 5

another_function-এর ঘোষণায় x নামে একটি প্যারামিটার রয়েছে। x-এর টাইপ i32 হিসাবে নির্দিষ্ট করা হয়েছে। যখন আমরা another_function-এ 5 পাস করি, println! ম্যাক্রো ফরম্যাট স্ট্রিং-এ x ধারণকারী কোঁকড়া বন্ধনীর জোড়ার জায়গায় 5 রাখে।

ফাংশনের সিগনেচারে, আপনাকে অবশ্যই প্রতিটি প্যারামিটারের টাইপ ঘোষণা করতে হবে। এটি রাস্টের ডিজাইনের একটি ইচ্ছাকৃত সিদ্ধান্ত: ফাংশন সংজ্ঞায় টাইপ অ্যানোটেশন প্রয়োজন হওয়ায় কম্পাইলারকে প্রায় কখনোই কোডের অন্য কোথাও আপনার কী টাইপ বোঝাতে চাইছেন তা বের করতে আপনার সাহায্য নিতে হয় না। কম্পাইলার আরও সহায়ক এরর বার্তা দিতে সক্ষম হয় যদি সে জানে ফাংশনটি কোন টাইপ আশা করছে।

একাধিক প্যারামিটার সংজ্ঞায়িত করার সময়, প্যারামিটার ঘোষণাগুলোকে কমা দিয়ে আলাদা করুন, যেমন:

ফাইলের নাম: src/main.rs

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

এই উদাহরণটি print_labeled_measurement নামে একটি ফাংশন তৈরি করে যার দুটি প্যারামিটার রয়েছে। প্রথম প্যারামিটারের নাম value এবং এটি একটি i32। দ্বিতীয়টির নাম unit_label এবং এর টাইপ char। ফাংশনটি তারপর value এবং unit_label উভয়ই ধারণকারী টেক্সট প্রিন্ট করে।

চলুন এই কোডটি চালানোর চেষ্টা করি। আপনার functions প্রজেক্টের src/main.rs ফাইলের বর্তমান প্রোগ্রামটিকে পূর্ববর্তী উদাহরণ দিয়ে প্রতিস্থাপন করুন এবং cargo run ব্যবহার করে এটি চালান:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/functions`
The measurement is: 5h```

যেহেতু আমরা `value`-এর জন্য `5` এবং `unit_label`-এর জন্য `'h'` মান দিয়ে ফাংশনটি কল করেছি, তাই প্রোগ্রামের আউটপুটে সেই মানগুলো রয়েছে।

### স্টেটমেন্ট এবং এক্সপ্রেশন (Statements and Expressions)

ফাংশন বডি একটি সিরিজের স্টেটমেন্ট (statements) দিয়ে গঠিত যা ঐচ্ছিকভাবে একটি এক্সপ্রেশন (expression) দিয়ে শেষ হতে পারে। এখন পর্যন্ত, আমরা যে ফাংশনগুলো দেখেছি সেগুলিতে একটি সমাপ্তি এক্সপ্রেশন অন্তর্ভুক্ত ছিল না, তবে আপনি একটি স্টেটমেন্টের অংশ হিসাবে একটি এক্সপ্রেশন দেখেছেন। যেহেতু রাস্ট একটি এক্সপ্রেশন-ভিত্তিক ভাষা, তাই এটি বোঝা একটি গুরুত্বপূর্ণ পার্থক্য। অন্যান্য ভাষার একই পার্থক্য নেই, তাই চলুন দেখি স্টেটমেন্ট এবং এক্সপ্রেশন কী এবং তাদের পার্থক্য ফাংশনের বডিকে কীভাবে প্রভাবিত করে।

-   স্টেটমেন্ট হলো এমন নির্দেশ যা কোনো কাজ সম্পাদন করে এবং কোনো মান রিটার্ন করে না।
-   এক্সপ্রেশন একটি ফলস্বরূপ মানে (resultant value) রূপান্তরিত হয়।

চলুন কিছু উদাহরণ দেখি।

আমরা আসলে ইতিমধ্যে স্টেটমেন্ট এবং এক্সপ্রেশন ব্যবহার করেছি। `let` কীওয়ার্ড দিয়ে একটি ভ্যারিয়েবল তৈরি করা এবং তাতে একটি মান অ্যাসাইন করা একটি স্টেটমেন্ট। লিস্টিং ৩-১-এ, `let y = 6;` একটি স্টেটমেন্ট।

<Listing number="3-1" file-name="src/main.rs" caption="একটি স্টেটমেন্ট ধারণকারী `main` ফাংশনের ঘোষণা">

```rust
fn main() {
    let y = 6;
}

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

fn main() {
    {                      // s is not valid here, since it's not yet declared
        let s = "hello";   // s is valid from this point forward

        // do stuff with s
    }                      // this scope is now over, and s is no longer valid
}

fn main() {
    let x = 5;
    let y = x;
}

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // Because i32 implements the Copy trait,
                                    // x does NOT move into the function,
                                    // so it's okay to use x afterward.

} // Here, x goes out of scope, then s. However, because s's value was moved,
  // nothing special happens.

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{some_string}");
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{some_integer}");
} // Here, some_integer goes out of scope. Nothing special happens.

fn main() {
    let s1 = gives_ownership();        // gives_ownership moves its return
                                       // value into s1

    let s2 = String::from("hello");    // s2 comes into scope

    let s3 = takes_and_gives_back(s2); // s2 is moved into
                                       // takes_and_gives_back, which also
                                       // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
  // happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {       // gives_ownership will move its
                                       // return value into the function
                                       // that calls it

    let some_string = String::from("yours"); // some_string comes into scope

    some_string                        // some_string is returned and
                                       // moves out to the calling
                                       // function
}

// This function takes a String and returns a String.
fn takes_and_gives_back(a_string: String) -> String {
    // a_string comes into
    // scope

    a_string  // a_string is returned and moves out to the calling function
}

fn main() {
    let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);

    println!("The length of '{s2}' is {len}.");
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() returns the length of a String

    (s, length)
}

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{r1}, {r2}");
}```

</Listing>

এখানে এররটি হলো:

```console
$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{r1}, {r2}");
  |               ---- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

এই এরর বলছে যে এই কোডটি অবৈধ কারণ আমরা একবারে একাধিকবার s-কে পরিবর্তনযোগ্য হিসাবে ধার করতে পারি না। প্রথম পরিবর্তনযোগ্য ধার r1-এ রয়েছে এবং এটি println!-এ ব্যবহৃত না হওয়া পর্যন্ত স্থায়ী হতে হবে, কিন্তু সেই পরিবর্তনযোগ্য রেফারেন্স তৈরির এবং তার ব্যবহারের মধ্যে, আমরা r2-তে আরেকটি পরিবর্তনযোগ্য রেফারেন্স তৈরি করার চেষ্টা করেছি যা r1-এর মতো একই ডেটা ধার করে।

একই ডেটার একাধিক পরিবর্তনযোগ্য রেফারেন্স থাকার সীমাবদ্ধতাটি পরিবর্তন করার সুযোগ দেয় কিন্তু খুব নিয়ন্ত্রিত উপায়ে। নতুন রাস্টেশিয়ানদের (Rustaceans) জন্য এটি একটি সমস্যা কারণ বেশিরভাগ ভাষা আপনাকে যখন ইচ্ছা পরিবর্তন করতে দেয়। এই সীমাবদ্ধতার সুবিধা হলো রাস্ট কম্পাইলের সময় ডেটা রেস (data races) প্রতিরোধ করতে পারে। একটি ডেটা রেস রেস কন্ডিশনের মতোই এবং এটি ঘটে যখন এই তিনটি আচরণ ঘটে:

• দুই বা ততোধিক পয়েন্টার একই সময়ে একই ডেটা অ্যাক্সেস করে।
• অন্তত একটি পয়েন্টার ডেটাতে লেখার জন্য ব্যবহৃত হচ্ছে।
• ডেটা অ্যাক্সেস সিঙ্ক্রোনাইজ করার জন্য কোনো ব্যবস্থা ব্যবহার করা হচ্ছে না।

ডেটা রেসগুলো অনির্ধারিত আচরণের (undefined behavior) কারণ হয় এবং রানটাইমে এগুলো খুঁজে বের করার চেষ্টা করার সময় নির্ণয় এবং ঠিক করা কঠিন হতে পারে; রাস্ট ডেটা রেসসহ কোড কম্পাইল করতে অস্বীকার করে এই সমস্যাটি প্রতিরোধ করে!

বরাবরের মতোই, আমরা কার্লি ব্র্যাকেট ব্যবহার করে একটি নতুন স্কোপ তৈরি করতে পারি, যা একাধিক পরিবর্তনযোগ্য রেফারেন্সের অনুমতি দেয়, শুধু একই সাথে নয়:

fn main() {
    let mut s = String::from("hello");

    {
        let r1 = &mut s;
    } // r1 goes out of scope here, so we can make a new reference with no problems.

    let r2 = &mut s;
}

রাস্ট পরিবর্তনযোগ্য এবং অপরিবর্তনীয় রেফারেন্স একত্রিত করার জন্যও একটি অনুরূপ নিয়ম প্রয়োগ করে। এই কোডটি একটি এরর তৈরি করে:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let r3 = &mut s; // BIG PROBLEM

    println!("{r1}, {r2}, and {r3}");
}

এখানে এররটি হলো:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &s; // no problem
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // no problem
6 |     let r3 = &mut s; // BIG PROBLEM
  |              ^^^^^^ mutable borrow occurs here
7 |
8 |     println!("{r1}, {r2}, and {r3}");
  |               ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

আমরা যখন একটি মানের একটি অপরিবর্তনীয় রেফারেন্স রাখি, তখন আমরা একটি পরিবর্তনযোগ্য রেফারেন্সও রাখতে পারি না।

অপরিবর্তনীয় রেফারেন্সের ব্যবহারকারীরা আশা করেন না যে মানটি হঠাৎ করে তাদের অজান্তেই পরিবর্তিত হয়ে যাবে! তবে, একাধিক অপরিবর্তনীয় রেফারেন্স অনুমোদিত কারণ যারা কেবল ডেটা পড়ছে তাদের কেউই অন্য কারো ডেটা পড়াকে প্রভাবিত করতে পারে না।

লক্ষ্য করুন যে একটি রেফারেন্সের স্কোপ যেখানে এটি তৈরি হয় সেখান থেকে শুরু হয় এবং সেই রেফারেন্সটি শেষবার ব্যবহৃত হওয়া পর্যন্ত চলতে থাকে। উদাহরণস্বরূপ, এই কোডটি কম্পাইল হবে কারণ অপরিবর্তনীয় রেফারেন্সগুলোর শেষ ব্যবহার হয় println!-এ, পরিবর্তনযোগ্য রেফারেন্সটি চালু করার আগে:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // Variables r1 and r2 will not be used after this point.

    let r3 = &mut s; // no problem
    println!("{r3}");
}

অপরিবর্তনীয় রেফারেন্স r1 এবং r2-এর স্কোপ println!-এর পরে শেষ হয়, যেখানে সেগুলি শেষবার ব্যবহৃত হয়, যা পরিবর্তনযোগ্য রেফারেন্স r3 তৈরি হওয়ার আগে। এই স্কোপগুলো ওভারল্যাপ করে না, তাই এই কোডটি অনুমোদিত: কম্পাইলার বলতে পারে যে স্কোপ শেষ হওয়ার আগেই রেফারেন্সটি আর ব্যবহৃত হচ্ছে না।

যদিও ধার করার এররগুলো কখনও কখনও হতাশাজনক হতে পারে, মনে রাখবেন যে এটি রাস্ট কম্পাইলার যা একটি সম্ভাব্য বাগ প্রথম দিকেই (রানটাইমের পরিবর্তে কম্পাইল টাইমে) নির্দেশ করছে এবং আপনাকে ঠিক কোথায় সমস্যাটি তা দেখাচ্ছে। তাহলে আপনাকে আর খুঁজে বের করতে হবে না কেন আপনার ডেটা আপনি যা ভেবেছিলেন তা নয়।

ড্যাংলিং রেফারেন্স (Dangling References)

পয়েন্টারসহ ভাষাগুলোতে, ভুলবশত একটি ড্যাংলিং পয়েন্টার (dangling pointer)—এমন একটি পয়েন্টার যা মেমরির এমন একটি অবস্থানকে নির্দেশ করে যা হয়তো অন্য কাউকে দেওয়া হয়েছে—তৈরি করা সহজ, কোনো মেমরি মুক্ত করার সময় সেই মেমরির একটি পয়েন্টার সংরক্ষণ করে। এর বিপরীতে, রাস্টে, কম্পাইলার গ্যারান্টি দেয় যে রেফারেন্সগুলো কখনই ড্যাংলিং রেফারেন্স হবে না: যদি আপনার কাছে কিছু ডেটার একটি রেফারেন্স থাকে, কম্পাইলার নিশ্চিত করবে যে ডেটার রেফারেন্সের আগে ডেটা স্কোপের বাইরে যাবে না।

আসুন একটি ড্যাংলিং রেফারেন্স তৈরি করার চেষ্টা করি যাতে দেখা যায় রাস্ট কীভাবে একটি কম্পাইল-টাইম এরর দিয়ে এগুলো প্রতিরোধ করে:

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

এখানে এররটি হলো:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
5 | fn dangle() -> &'static String {
  |                 +++++++
help: instead, you are more likely to want to return an owned value
  |
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
  |

error[E0515]: cannot return reference to local variable `s`
 --> src/main.rs:8:5
  |
8 |     &s
  |     ^^ returns a reference to data owned by the current function

Some errors have detailed explanations: E0106, E0515.
For more information about an error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 2 previous errors

এই এরর বার্তাটি এমন একটি বৈশিষ্ট্য উল্লেখ করে যা আমরা এখনও আলোচনা করিনি: লাইফটাইম (lifetimes)। আমরা অধ্যায় ১০-এ লাইফটাইম নিয়ে বিস্তারিত আলোচনা করব। কিন্তু, আপনি যদি লাইফটাইম সম্পর্কিত অংশগুলো উপেক্ষা করেন, বার্তাটিতে এই কোডটি কেন একটি সমস্যা তার মূল চাবিকাঠি রয়েছে:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from

আসুন আমাদের dangle কোডের প্রতিটি পর্যায়ে ঠিক কী ঘটছে তা আরও ঘনিষ্ঠভাবে দেখি:

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // dangle returns a reference to a String

    let s = String::from("hello"); // s is a new String

    &s // we return a reference to the String, s
} // Here, s goes out of scope and is dropped, so its memory goes away.
  // Danger!

যেহেতু s dangle এর ভিতরে তৈরি করা হয়েছে, তাই dangle-এর কোড শেষ হয়ে গেলে, s ডিঅ্যালোকেট (deallocated) করা হবে। কিন্তু আমরা এটির একটি রেফারেন্স ফেরত দেওয়ার চেষ্টা করেছি। এর মানে এই রেফারেন্সটি একটি অবৈধ String-কে নির্দেশ করবে। এটা মোটেও ভালো না! রাস্ট আমাদের এটা করতে দেবে না।

এখানের সমাধান হলো String সরাসরি ফেরত দেওয়া:

fn main() {
    let string = no_dangle();
}

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

এটি কোনো সমস্যা ছাড়াই কাজ করে। মালিকানা মুভ (moved out) হয়ে যায়, এবং কিছুই ডিঅ্যালোকেট করা হয় না।

রেফারেন্সের নিয়মাবলী (The Rules of References)

আসুন আমরা রেফারেন্স সম্পর্কে যা আলোচনা করেছি তা সংক্ষেপে দেখে নিই:

• যেকোনো নির্দিষ্ট সময়ে, আপনার কাছে হয় একটি পরিবর্তনযোগ্য রেফারেন্স অথবা যেকোনো সংখ্যক অপরিবর্তনীয় রেফারেন্স থাকতে পারে।
• রেফারেন্স অবশ্যই সবসময় বৈধ হতে হবে।

এর পরে, আমরা একটি ভিন্ন ধরনের রেফারেন্স দেখব: স্লাইস (slices)।

স্লাইস টাইপ (The Slice Type)

স্লাইস (Slices) আপনাকে একটি কালেকশনের মধ্যে থাকা উপাদানগুলোর একটি অবিচ্ছিন্ন ক্রমকে (contiguous sequence) রেফারেন্স করতে দেয়। স্লাইস এক ধরনের রেফারেন্স, তাই এর কোনো মালিকানা (ownership) নেই।

এখানে একটি ছোট প্রোগ্রামিং সমস্যা দেওয়া হলো: একটি ফাংশন লিখুন যা স্পেস দ্বারা বিভক্ত শব্দযুক্ত একটি স্ট্রিং নেয় এবং সেই স্ট্রিংয়ের প্রথম শব্দটি রিটার্ন করে। যদি ফাংশনটি স্ট্রিংয়ের মধ্যে কোনো স্পেস খুঁজে না পায়, তার মানে পুরো স্ট্রিংটিই একটি শব্দ, তাই সম্পূর্ণ স্ট্রিংটিই রিটার্ন করা উচিত।

দ্রষ্টব্য: স্ট্রিং স্লাইস পরিচিত করানোর উদ্দেশ্যে, আমরা এই বিভাগে শুধুমাত্র ASCII ধরে নিচ্ছি; অধ্যায় ৮-এর "স্ট্রিং সহ UTF-8 এনকোডেড টেক্সট সংরক্ষণ" বিভাগে UTF-8 হ্যান্ডলিং নিয়ে আরও বিস্তারিত আলোচনা করা হয়েছে।

আসুন দেখি স্লাইস ব্যবহার না করে আমরা এই ফাংশনের সিগনেচার কীভাবে লিখতাম, যাতে স্লাইস যে সমস্যার সমাধান করবে তা বোঝা যায়:

fn first_word(s: &String) -> ?

first_word ফাংশনটির একটি প্যারামিটার আছে যার টাইপ &String। আমাদের মালিকানার প্রয়োজন নেই, তাই এটি ঠিক আছে। (প্রচলিত রাস্ট কোডে, ফাংশনগুলো প্রয়োজন না হলে তাদের আর্গুমেন্টের মালিকানা নেয় না, এবং এর কারণগুলো আমরা যত এগোব তত স্পষ্ট হবে।) কিন্তু আমাদের কী রিটার্ন করা উচিত? আমাদের কাছে একটি স্ট্রিংয়ের অংশ নিয়ে কথা বলার কোনো উপায় নেই। তবে, আমরা শব্দের শেষের ইনডেক্সটি রিটার্ন করতে পারি, যা একটি স্পেস দ্বারা নির্দেশিত। আসুন তালিকা ৪-৭-এ দেখানো উপায়ে চেষ্টা করি।

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

যেহেতু আমাদের String এর প্রতিটি উপাদান ধরে ধরে পরীক্ষা করতে হবে এবং দেখতে হবে কোনো মান স্পেস কিনা, তাই আমরা as_bytes মেথড ব্যবহার করে আমাদের String-কে একটি বাইট অ্যারেতে রূপান্তর করব।

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

এরপরে, আমরা iter মেথড ব্যবহার করে বাইট অ্যারের উপর একটি ইটারেটর (iterator) তৈরি করি:

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

আমরা অধ্যায় ১৩-এ ইটারেটর নিয়ে আরও বিস্তারিত আলোচনা করব। আপাতত, জেনে রাখুন যে iter একটি মেথড যা একটি কালেকশনের প্রতিটি উপাদান রিটার্ন করে এবং enumerate iter-এর ফলাফলকে মুড়িয়ে (wrap) প্রতিটি উপাদানকে একটি টাপলের অংশ হিসাবে রিটার্ন করে। enumerate থেকে রিটার্ন করা টাপলের প্রথম উপাদানটি হলো ইনডেক্স, এবং দ্বিতীয় উপাদানটি হলো উপাদানের একটি রেফারেন্স। এটি আমাদের নিজেদের ইনডেক্স গণনা করার চেয়ে একটু বেশি সুবিধাজনক।

যেহেতু enumerate মেথডটি একটি টাপল রিটার্ন করে, আমরা সেই টাপলটিকে ডিস্ট্রাকচার (destructure) করতে প্যাটার্ন ব্যবহার করতে পারি। আমরা অধ্যায় ৬-এ প্যাটার্ন নিয়ে আরও আলোচনা করব। for লুপে, আমরা একটি প্যাটার্ন নির্দিষ্ট করি যেখানে টাপলের ইনডেক্সের জন্য i এবং একক বাইটের জন্য &item রয়েছে। যেহেতু আমরা .iter().enumerate() থেকে উপাদানের একটি রেফারেন্স পাই, তাই আমরা প্যাটার্নে & ব্যবহার করি।

for লুপের ভিতরে, আমরা বাইট লিটারেল সিনট্যাক্স ব্যবহার করে স্পেস প্রতিনিধিত্বকারী বাইটটি অনুসন্ধান করি। যদি আমরা একটি স্পেস খুঁজে পাই, আমরা অবস্থানটি রিটার্ন করি। অন্যথায়, আমরা s.len() ব্যবহার করে স্ট্রিংয়ের দৈর্ঘ্য রিটার্ন করি।

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

এখন আমাদের কাছে স্ট্রিংয়ের প্রথম শব্দের শেষের ইনডেক্স খুঁজে বের করার একটি উপায় আছে, কিন্তু একটি সমস্যা আছে। আমরা শুধু একটি usize রিটার্ন করছি, কিন্তু এটি শুধুমাত্র &String-এর প্রেক্ষাপটেই একটি অর্থপূর্ণ সংখ্যা। অন্য কথায়, যেহেতু এটি String থেকে একটি পৃথক মান, তাই ভবিষ্যতে এটি বৈধ থাকবে এমন কোনো নিশ্চয়তা নেই। তালিকা ৪-৮-এর প্রোগ্রামটি বিবেচনা করুন যা তালিকা ৪-৭-এর first_word ফাংশনটি ব্যবহার করে।

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word will get the value 5

    s.clear(); // this empties the String, making it equal to ""

    // word still has the value 5 here, but s no longer has any content that we
    // could meaningfully use with the value 5, so word is now totally invalid!
}

এই প্রোগ্রামটি কোনো এরর ছাড়াই কম্পাইল হয় এবং s.clear() কল করার পরে word ব্যবহার করলেও তা হতো। যেহেতু word s-এর অবস্থার সাথে একেবারেই সংযুক্ত নয়, word-এ এখনও 5 মানটি রয়েছে। আমরা s ভ্যারিয়েবলের সাথে সেই 5 মানটি ব্যবহার করে প্রথম শব্দটি বের করার চেষ্টা করতে পারতাম, কিন্তু এটি একটি বাগ হতো কারণ word-এ 5 সংরক্ষণ করার পর s-এর বিষয়বস্তু পরিবর্তিত হয়েছে।

s-এর ডেটার সাথে word-এর ইনডেক্সটি অসামঞ্জস্যপূর্ণ হয়ে যাওয়ার চিন্তা করাটা ক্লান্তিকর এবং ভুল-প্রবণ! এই ইনডেক্সগুলো পরিচালনা করা আরও ভঙ্গুর হয়ে যায় যদি আমরা একটি second_word ফাংশন লিখি। এর সিগনেচারটি এমন হতে হবে:

fn second_word(s: &String) -> (usize, usize) {

এখন আমরা একটি শুরুর এবং একটি শেষের ইনডেক্স ট্র্যাক করছি, এবং আমাদের কাছে আরও বেশি মান রয়েছে যা একটি নির্দিষ্ট অবস্থার ডেটা থেকে গণনা করা হয়েছে কিন্তু সেই অবস্থার সাথে মোটেই আবদ্ধ নয়। আমাদের তিনটি असंबंधित ভ্যারিয়েবল রয়েছে যা সিঙ্কে রাখতে হবে।

ভাগ্যক্রমে, রাস্টের এই সমস্যার একটি সমাধান আছে: স্ট্রিং স্লাইস।

স্ট্রিং স্লাইস (String Slices)

একটি স্ট্রিং স্লাইস (string slice) হলো একটি String-এর উপাদানগুলোর একটি অবিচ্ছিন্ন ক্রমের রেফারেন্স, এবং এটি দেখতে এইরকম:

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

সম্পূর্ণ String-এর রেফারেন্সের পরিবর্তে, hello হলো String-এর একটি অংশের রেফারেন্স, যা অতিরিক্ত [0..5] অংশে নির্দিষ্ট করা হয়েছে। আমরা ব্র্যাকেটের মধ্যে একটি রেঞ্জ ব্যবহার করে স্লাইস তৈরি করি, [starting_index..ending_index] নির্দিষ্ট করে, যেখানে starting_index হলো স্লাইসের প্রথম অবস্থান এবং ending_index হলো স্লাইসের শেষ অবস্থানের চেয়ে এক বেশি। অভ্যন্তরীণভাবে, স্লাইস ডেটা স্ট্রাকচারটি স্লাইসের শুরুর অবস্থান এবং দৈর্ঘ্য সংরক্ষণ করে, যা ending_index বিয়োগ starting_index-এর সাথে মিলে যায়। সুতরাং, let world = &s[6..11];-এর ক্ষেত্রে, world এমন একটি স্লাইস হবে যা s-এর ইনডেক্স ৬-এর বাইটের একটি পয়েন্টার এবং ৫ দৈর্ঘ্যের একটি মান ধারণ করবে।

চিত্র ৪-৭ এটি একটি ডায়াগ্রামে দেখাচ্ছে।

চিত্র ৪-৭: একটি String-এর অংশকে নির্দেশকারী স্ট্রিং স্লাইস

রাস্টের .. রেঞ্জ সিনট্যাক্সের সাথে, আপনি যদি ইনডেক্স ০ থেকে শুরু করতে চান, আপনি দুটি পিরিয়ডের আগের মানটি বাদ দিতে পারেন। অন্য কথায়, এগুলো সমান:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
}

একইভাবে, যদি আপনার স্লাইস String-এর শেষ বাইট অন্তর্ভুক্ত করে, আপনি শেষের সংখ্যাটি বাদ দিতে পারেন। এর মানে হলো এগুলো সমান:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
}

আপনি সম্পূর্ণ স্ট্রিংয়ের একটি স্লাইস নিতে উভয় মানই বাদ দিতে পারেন। সুতরাং এগুলো সমান:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

দ্রষ্টব্য: স্ট্রিং স্লাইস রেঞ্জের ইনডেক্স অবশ্যই বৈধ UTF-8 ক্যারেক্টার সীমানায় হতে হবে। আপনি যদি একটি মাল্টিবাইট ক্যারেক্টারের মাঝখানে একটি স্ট্রিং স্লাইস তৈরি করার চেষ্টা করেন, আপনার প্রোগ্রাম একটি এরর সহ বন্ধ হয়ে যাবে।

এই সমস্ত তথ্য মাথায় রেখে, আসুন first_word কে একটি স্লাইস রিটার্ন করার জন্য পুনরায় লিখি। যে টাইপটি “স্ট্রিং স্লাইস” বোঝায় তা &str হিসাবে লেখা হয়:

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

আমরা তালিকা ৪-৭-এর মতোই শব্দের শেষের জন্য ইনডেক্সটি পাই, একটি স্পেসের প্রথম উপস্থিতির সন্ধান করে। যখন আমরা একটি স্পেস খুঁজে পাই, আমরা স্ট্রিংয়ের শুরু এবং স্পেসের ইনডেক্সকে শুরুর এবং শেষের ইনডেক্স হিসাবে ব্যবহার করে একটি স্ট্রিং স্লাইস রিটার্ন করি।

এখন যখন আমরা first_word কল করি, আমরা একটি একক মান ফেরত পাই যা অন্তর্নিহিত ডেটার সাথে আবদ্ধ। মানটি স্লাইসের শুরুর পয়েন্টের একটি রেফারেন্স এবং স্লাইসের উপাদানগুলোর সংখ্যা নিয়ে গঠিত।

একটি স্লাইস রিটার্ন করা second_word ফাংশনের জন্যও কাজ করবে:

fn second_word(s: &String) -> &str {

এখন আমাদের একটি সহজবোধ্য API আছে যা ভুল করা অনেক কঠিন কারণ কম্পাইলার নিশ্চিত করবে যে String-এর রেফারেন্সগুলো বৈধ থাকবে। তালিকা ৪-৮-এর প্রোগ্রামের বাগটি মনে আছে, যখন আমরা প্রথম শব্দের শেষের ইনডেক্স পেয়েছিলাম কিন্তু তারপর স্ট্রিংটি খালি করে দিয়েছিলাম যাতে আমাদের ইনডেক্সটি অবৈধ হয়ে যায়? সেই কোডটি যৌক্তিকভাবে ভুল ছিল কিন্তু কোনো তাৎক্ষণিক এরর দেখায়নি। সমস্যাগুলো পরে দেখা যেত যদি আমরা খালি স্ট্রিংয়ের সাথে প্রথম শব্দের ইনডেক্স ব্যবহার করার চেষ্টা চালিয়ে যেতাম। স্লাইস এই বাগটিকে অসম্ভব করে তোলে এবং আমাদের কোডের সমস্যা সম্পর্কে অনেক আগে জানিয়ে দেয়। first_word-এর স্লাইস সংস্করণ ব্যবহার করলে একটি কম্পাইল-টাইম এরর আসবে:

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {word}");
}

এখানে কম্পাইলার এররটি হলো:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:18:5
   |
16 |     let word = first_word(&s);
   |                           -- immutable borrow occurs here
17 |
18 |     s.clear(); // error!
   |     ^^^^^^^^^ mutable borrow occurs here
19 |
20 |     println!("the first word is: {word}");
   |                                  ------ immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

ধার করার নিয়ম থেকে মনে করুন, যদি আমাদের কোনো কিছুর একটি অপরিবর্তনীয় রেফারেন্স থাকে, আমরা একই সাথে একটি পরিবর্তনযোগ্য রেফারেন্স নিতে পারি না। যেহেতু clear-কে String-কে ছোট করতে হয়, তাই এর একটি পরিবর্তনযোগ্য রেফারেন্স প্রয়োজন। clear কলের পরে println! word-এর রেফারেন্স ব্যবহার করে, তাই সেই সময়ে অপরিবর্তনীয় রেফারেন্সটি অবশ্যই সক্রিয় থাকতে হবে। রাস্ট clear-এর পরিবর্তনযোগ্য রেফারেন্স এবং word-এর অপরিবর্তনীয় রেফারেন্সকে একই সময়ে বিদ্যমান থাকতে দেয় না, এবং কম্পাইলেশন ব্যর্থ হয়। রাস্ট কেবল আমাদের API ব্যবহার করা সহজ করেনি, বরং এটি কম্পাইলের সময় একটি সম্পূর্ণ শ্রেণীর এররও দূর করেছে!

স্ট্রিং লিটারেলস (String Literals) হলো স্লাইস

মনে করুন আমরা বলেছিলাম যে স্ট্রিং লিটারেলগুলো বাইনারির ভিতরে সংরক্ষিত থাকে। এখন যেহেতু আমরা স্লাইস সম্পর্কে জানি, আমরা স্ট্রিং লিটারেলগুলো সঠিকভাবে বুঝতে পারি:

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

s-এর টাইপ এখানে &str: এটি বাইনারির সেই নির্দিষ্ট পয়েন্টের দিকে নির্দেশকারী একটি স্লাইস। এই কারণেই স্ট্রিং লিটারেলগুলো অপরিবর্তনীয় (immutable); &str একটি অপরিবর্তনীয় রেফারেন্স।

প্যারামিটার হিসাবে স্ট্রিং স্লাইস

আপনি যে লিটারেল এবং String মানগুলোর স্লাইস নিতে পারেন তা জানার ফলে আমরা first_word-এ আরও একটি উন্নতি করতে পারি, এবং তা হলো এর সিগনেচার:

fn first_word(s: &String) -> &str {

একজন আরও অভিজ্ঞ রাস্টেশিয়ান (Rustacean) তালিকা ৪-৯-এ দেখানো সিগনেচারটি লিখবেন কারণ এটি আমাদের &String মান এবং &str মান উভয়ের উপর একই ফাংশন ব্যবহার করতে দেয়।

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or
    // whole.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

যদি আমাদের একটি স্ট্রিং স্লাইস থাকে, আমরা সরাসরি সেটি পাস করতে পারি। যদি আমাদের একটি String থাকে, আমরা String-এর একটি স্লাইস বা String-এর একটি রেফারেন্স পাস করতে পারি। এই নমনীয়তা ডেরিফ কোয়ারশনস (deref coercions)-এর সুবিধা নেয়, যা আমরা অধ্যায় ১৫-এর "ফাংশন এবং মেথডের সাথে ইমপ্লিসিট ডেরিফ কোয়ারশনস" বিভাগে আলোচনা করব।

একটি String-এর রেফারেন্সের পরিবর্তে একটি স্ট্রিং স্লাইস নেওয়ার জন্য একটি ফাংশন ডিফাইন করা আমাদের API-কে কোনো কার্যকারিতা না হারিয়ে আরও সাধারণ এবং দরকারী করে তোলে:

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or
    // whole.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

অন্যান্য স্লাইস (Other Slices)

স্ট্রিং স্লাইস, যেমন আপনি কল্পনা করতে পারেন, স্ট্রিংয়ের জন্য নির্দিষ্ট। কিন্তু আরও একটি সাধারণ স্লাইস টাইপও আছে। এই অ্যারেটি বিবেচনা করুন:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

ঠিক যেমন আমরা একটি স্ট্রিংয়ের অংশকে রেফার করতে চাই, আমরা একটি অ্যারের অংশকে রেফার করতে চাইতে পারি। আমরা এটি এভাবে করব:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

এই স্লাইসটির টাইপ &[i32]। এটি স্ট্রিং স্লাইসের মতোই কাজ করে, প্রথম উপাদানের একটি রেফারেন্স এবং একটি দৈর্ঘ্য সংরক্ষণ করে। আপনি এই ধরনের স্লাইস সব ধরনের অন্যান্য কালেকশনের জন্য ব্যবহার করবেন। আমরা অধ্যায় ৮-এ ভেক্টর নিয়ে আলোচনা করার সময় এই কালেকশনগুলো নিয়ে বিস্তারিত আলোচনা করব।

সারসংক্ষেপ (Summary)

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

মালিকানা রাস্টের অন্যান্য অনেক অংশ কীভাবে কাজ করে তা প্রভাবিত করে, তাই আমরা বইয়ের বাকি অংশে এই ধারণাগুলো নিয়ে আরও আলোচনা করব। চলুন অধ্যায় ৫-এ যাই এবং struct-এ ডেটার অংশগুলোকে একত্রিত করা দেখি।

সম্পর্কিত ডেটা গঠন করার জন্য struct ব্যবহার

একটি struct বা স্ট্রাকচার (structure) হলো একটি কাস্টম ডেটা টাইপ, যা আপনাকে একাধিক সম্পর্কিত মানকে একসাথে একটি অর্থপূর্ণ গ্রুপ হিসাবে প্যাকেজ করতে এবং সেগুলোকে নাম দিতে সাহায্য করে। আপনি যদি কোনো অবজেক্ট-ওরিয়েন্টেড (object-oriented) ভাষার সাথে পরিচিত হন, তবে একটি struct হলো একটি অবজেক্টের ডেটা অ্যাট্রিবিউটের (data attributes) মতো। এই অধ্যায়ে, আমরা টাপল (tuples) এবং struct-এর মধ্যে তুলনা ও পার্থক্য তুলে ধরব, যাতে আপনার পূর্ববর্তী জ্ঞানের উপর ভিত্তি করে দেখানো যায় কখন ডেটা গ্রুপ করার জন্য struct একটি ভালো উপায়।

আমরা দেখাব কীভাবে struct ডিফাইন (define) এবং ইনস্ট্যানশিয়েট (instantiate) করতে হয়। একটি struct টাইপের সাথে সম্পর্কিত আচরণ (behavior) নির্দিষ্ট করার জন্য, আমরা অ্যাসোসিয়েটেড ফাংশন (associated functions) ডিফাইন করার পদ্ধতি নিয়ে আলোচনা করব, বিশেষ করে সেই ফাংশনগুলো যা মেথড (methods) নামে পরিচিত। struct এবং enum (অধ্যায় ৬-এ আলোচিত) হলো আপনার প্রোগ্রামের ডোমেইনে নতুন টাইপ তৈরি করার মূল বিল্ডিং ব্লক (building blocks), যা আপনাকে রাস্টের কম্পাইল-টাইম টাইপ চেকিং (compile-time type checking) এর সম্পূর্ণ সুবিধা নিতে সাহায্য করে।

struct ডিফাইন এবং ইনস্ট্যানশিয়েট করা (Defining and Instantiating Structs)

struct অনেকটা টাপলের (tuple) মতোই, যা "টাপল টাইপ" বিভাগে আলোচনা করা হয়েছে, কারণ উভয়ই একাধিক সম্পর্কিত মান ধারণ করে। টাপলের মতো, struct-এর অংশগুলো বিভিন্ন টাইপের হতে পারে। তবে টাপলের সাথে এর পার্থক্য হলো, struct-এ আপনি প্রতিটি ডেটার একটি নাম দেবেন যাতে মানগুলোর অর্থ স্পষ্ট হয়। এই নামগুলো যোগ করার ফলে struct টাপলের চেয়ে বেশি নমনীয় হয়: আপনাকে কোনো ইনস্ট্যান্সের মান নির্দিষ্ট বা অ্যাক্সেস করার জন্য ডেটার ক্রমের উপর নির্ভর করতে হয় না।

একটি struct ডিফাইন করার জন্য, আমরা struct কীওয়ার্ডটি লিখি এবং পুরো struct-টির একটি নাম দিই। একটি struct-এর নাম এমন হওয়া উচিত যা একসাথে গ্রুপ করা ডেটার গুরুত্ব বর্ণনা করে। তারপর, কার্লি ব্র্যাকেটের ভিতরে, আমরা ডেটার অংশগুলোর নাম এবং টাইপ ডিফাইন করি, যেগুলোকে আমরা ফিল্ড (fields) বলি। উদাহরণস্বরূপ, তালিকা ৫-১ একটি struct দেখাচ্ছে যা একটি ব্যবহারকারীর অ্যাকাউন্ট সম্পর্কে তথ্য সংরক্ষণ করে।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}

একটি struct ডিফাইন করার পর এটি ব্যবহার করার জন্য, আমরা প্রতিটি ফিল্ডের জন্য সুনির্দিষ্ট মান নির্দিষ্ট করে সেই struct-এর একটি ইনস্ট্যান্স (instance) তৈরি করি। আমরা struct-এর নাম উল্লেখ করে একটি ইনস্ট্যান্স তৈরি করি এবং তারপর কার্লি ব্র্যাকেটের মধ্যে key: value জোড়া যোগ করি, যেখানে কী-গুলো (keys) হলো ফিল্ডগুলোর নাম এবং ভ্যালুগুলো (values) হলো সেই ডেটা যা আমরা সেই ফিল্ডগুলোতে সংরক্ষণ করতে চাই। আমাদের ফিল্ডগুলোকে struct-এ যে ক্রমে ঘোষণা করা হয়েছে সেই একই ক্রমে নির্দিষ্ট করতে হবে না। অন্য কথায়, struct-এর সংজ্ঞাটি টাইপের জন্য একটি সাধারণ টেমপ্লেটের মতো, এবং ইনস্ট্যান্সগুলো সেই টেমপ্লেটটি নির্দিষ্ট ডেটা দিয়ে পূরণ করে টাইপের মান তৈরি করে। উদাহরণস্বরূপ, আমরা তালিকা ৫-২-এ দেখানো উপায়ে একটি নির্দিষ্ট ব্যবহারকারী ঘোষণা করতে পারি।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}

একটি struct থেকে একটি নির্দিষ্ট মান পেতে, আমরা ডট নোটেশন (dot notation) ব্যবহার করি। উদাহরণস্বরূপ, এই ব্যবহারকারীর ইমেল ঠিকানা অ্যাক্সেস করতে, আমরা user1.email ব্যবহার করি। যদি ইনস্ট্যান্সটি পরিবর্তনযোগ্য (mutable) হয়, আমরা ডট নোটেশন ব্যবহার করে এবং একটি নির্দিষ্ট ফিল্ডে মান অ্যাসাইন করে একটি মান পরিবর্তন করতে পারি। তালিকা ৫-৩ দেখাচ্ছে কীভাবে একটি পরিবর্তনযোগ্য User ইনস্ট্যান্সের email ফিল্ডের মান পরিবর্তন করতে হয়।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");
}

মনে রাখবেন যে পুরো ইনস্ট্যান্সটি অবশ্যই পরিবর্তনযোগ্য হতে হবে; রাস্ট আমাদের শুধুমাত্র নির্দিষ্ট কিছু ফিল্ডকে পরিবর্তনযোগ্য হিসাবে চিহ্নিত করার অনুমতি দেয় না। যেকোনো এক্সপ্রেশনের মতো, আমরা ফাংশন বডির শেষ এক্সপ্রেশন হিসাবে struct-এর একটি নতুন ইনস্ট্যান্স তৈরি করে সেই নতুন ইনস্ট্যান্সটি উহ্যভাবে (implicitly) রিটার্ন করতে পারি।

তালিকা ৫-৪ একটি build_user ফাংশন দেখাচ্ছে যা প্রদত্ত ইমেল এবং ব্যবহারকারীর নাম সহ একটি User ইনস্ট্যান্স রিটার্ন করে। active ফিল্ডটি true মান পায়, এবং sign_in_count একটি মান 1 পায়।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username: username,
        email: email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}```

</Listing>

ফাংশন প্যারামিটারগুলোকে `struct` ফিল্ডগুলোর একই নামে নামকরণ করা যুক্তিযুক্ত, কিন্তু `email` এবং `username` ফিল্ডের নাম এবং ভ্যারিয়েবলগুলো পুনরাবৃত্তি করা কিছুটা ক্লান্তিকর। যদি `struct`-এ আরও ফিল্ড থাকত, তবে প্রতিটি নামের পুনরাবৃত্তি আরও বিরক্তিকর হয়ে উঠত। ভাগ্যক্রমে, একটি সুবিধাজনক সংক্ষিপ্ত উপায় আছে!

<!-- Old heading. Do not remove or links may break. -->

<a id="using-the-field-init-shorthand-when-variables-and-fields-have-the-same-name"></a>

## ফিল্ড ইনিশিয়ালাইজেশন শর্টহ্যান্ড ব্যবহার (Using the Field Init Shorthand)

যেহেতু তালিকা ৫-৪-এ প্যারামিটারের নাম এবং `struct` ফিল্ডের নাম ঠিক একই, তাই আমরা `build_user` ফাংশনটিকে পুনরায় লেখার জন্য _ফিল্ড ইনিশিয়ালাইজেশন শর্টহ্যান্ড_ (field init shorthand) সিনট্যাক্স ব্যবহার করতে পারি যাতে এটি ঠিক একইভাবে আচরণ করে কিন্তু `username` এবং `email`-এর পুনরাবৃত্তি না থাকে, যেমনটি তালিকা ৫-৫-এ দেখানো হয়েছে।

<Listing number="5-5" file-name="src/main.rs" caption="একটি `build_user` ফাংশন যা ফিল্ড ইনিশিয়ালাইজেশন শর্টহ্যান্ড ব্যবহার করে কারণ `username` এবং `email` প্যারামিটারগুলোর নাম `struct` ফিল্ডগুলোর নামের সমান">

```rust
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

এখানে, আমরা User struct-এর একটি নতুন ইনস্ট্যান্স তৈরি করছি, যার email নামে একটি ফিল্ড রয়েছে। আমরা email ফিল্ডের মান build_user ফাংশনের email প্যারামিটারের মানে সেট করতে চাই। যেহেতু email ফিল্ড এবং email প্যারামিটারের নাম একই, আমাদের কেবল email লিখতে হবে, email: email লেখার পরিবর্তে।

স্ট্রাকট আপডেট সিনট্যাক্স দিয়ে অন্য ইনস্ট্যান্স থেকে ইনস্ট্যান্স তৈরি

প্রায়শই একই ধরনের অন্য একটি ইনস্ট্যান্সের বেশিরভাগ মান ব্যবহার করে একটি struct-এর নতুন ইনস্ট্যান্স তৈরি করা দরকারী হয়, কিন্তু কিছু মান পরিবর্তন করতে হয়। আপনি এটি স্ট্রাকট আপডেট সিনট্যাক্স (struct update syntax) ব্যবহার করে করতে পারেন।

প্রথমে, তালিকা ৫-৬-এ আমরা আপডেট সিনট্যাক্স ছাড়া নিয়মিতভাবে user2-তে একটি নতুন User ইনস্ট্যান্স কীভাবে তৈরি করতে হয় তা দেখাই। আমরা email-এর জন্য একটি নতুন মান সেট করি কিন্তু অন্যথায় তালিকা ৫-২-এ তৈরি করা user1-এর একই মান ব্যবহার করি।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}

স্ট্রাকট আপডেট সিনট্যাক্স ব্যবহার করে, আমরা কম কোডে একই ফলাফল অর্জন করতে পারি, যেমনটি তালিকা ৫-৭-এ দেখানো হয়েছে। .. সিনট্যাক্সটি নির্দিষ্ট করে যে বাকি ফিল্ডগুলো যা স্পষ্টভাবে সেট করা হয়নি সেগুলোর মান প্রদত্ত ইনস্ট্যান্সের ফিল্ডগুলোর মতোই হবে।

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

তালিকা ৫-৭-এর কোডটি user2-তে একটি ইনস্ট্যান্স তৈরি করে যার email-এর জন্য একটি ভিন্ন মান রয়েছে কিন্তু user1-এর username, active এবং sign_in_count ফিল্ডগুলোর মান একই। ..user1 অবশ্যই শেষে আসতে হবে যাতে নির্দিষ্ট করা যায় যে কোনো বাকি ফিল্ড তাদের মান user1-এর সংশ্লিষ্ট ফিল্ড থেকে পাবে, কিন্তু আমরা struct-এর সংজ্ঞায় ফিল্ডগুলোর ক্রম নির্বিশেষে যেকোনো ক্রমে যতগুলো ফিল্ডের জন্য মান নির্দিষ্ট করতে পারি।

মনে রাখবেন যে স্ট্রাকট আপডেট সিনট্যাক্স একটি অ্যাসাইনমেন্টের মতো = ব্যবহার করে; এর কারণ এটি ডেটা মুভ (moves) করে, যেমনটি আমরা "Move এর মাধ্যমে ভ্যারিয়েবল এবং ডেটার মিথস্ক্রিয়া" বিভাগে দেখেছি। এই উদাহরণে, user2 তৈরি করার পরে আমরা আর user1 ব্যবহার করতে পারি না কারণ user1-এর username ফিল্ডের String user2-তে মুভ করা হয়েছে। যদি আমরা user2-কে email এবং username উভয়ের জন্য নতুন String মান দিতাম, এবং এইভাবে user1 থেকে শুধুমাত্র active এবং sign_in_count মান ব্যবহার করতাম, তাহলে user2 তৈরি করার পরেও user1 বৈধ থাকত। active এবং sign_in_count উভয়ই এমন টাইপ যা Copy ট্রেইট ইমপ্লিমেন্ট করে, তাই "শুধুমাত্র-স্ট্যাক ডেটা: কপি" বিভাগে আলোচনা করা আচরণ প্রযোজ্য হবে। আমরা এই উদাহরণে এখনও user1.email ব্যবহার করতে পারি, কারণ এর মান user1 থেকে মুভ করা হয়নি।

বিভিন্ন টাইপ তৈরি করতে নামবিহীন ফিল্ড সহ টাপল স্ট্রাকট ব্যবহার

রাস্ট টাপলের মতো দেখতে struct সমর্থন করে, যাকে টাপল স্ট্রাকট (tuple structs) বলা হয়। টাপল স্ট্রাকটগুলোতে struct নামের অতিরিক্ত অর্থ থাকে তবে তাদের ফিল্ডগুলোর সাথে কোনো নাম যুক্ত থাকে না; বরং, তাদের কেবল ফিল্ডগুলোর টাইপ থাকে। টাপল স্ট্রাকটগুলো দরকারী যখন আপনি পুরো টাপলটিকে একটি নাম দিতে চান এবং টাপলটিকে অন্য টাপল থেকে একটি ভিন্ন টাইপ করতে চান, এবং যখন একটি নিয়মিত struct-এর মতো প্রতিটি ফিল্ডের নামকরণ করা ভার্বোস (verbose) বা অপ্রয়োজনীয় (redundant) হবে।

একটি টাপল স্ট্রাকট ডিফাইন করতে, struct কীওয়ার্ড এবং struct-এর নাম দিয়ে শুরু করুন এবং তারপরে টাপলের টাইপগুলো দিন। উদাহরণস্বরূপ, এখানে আমরা Color এবং Point নামে দুটি টাপল স্ট্রাকট ডিফাইন এবং ব্যবহার করি:

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

মনে রাখবেন যে black এবং origin মানগুলো ভিন্ন টাইপের কারণ সেগুলো ভিন্ন টাপল স্ট্রাকটের ইনস্ট্যান্স। আপনি যে প্রতিটি struct ডিফাইন করেন তা তার নিজস্ব টাইপ, যদিও struct-এর ভিতরের ফিল্ডগুলোর টাইপ একই হতে পারে। উদাহরণস্বরূপ, একটি ফাংশন যা Color টাইপের একটি প্যারামিটার নেয় তা আর্গুমেন্ট হিসাবে একটি Point নিতে পারে না, যদিও উভয় টাইপই তিনটি i32 মান দিয়ে তৈরি। অন্যথায়, টাপল স্ট্রাকট ইনস্ট্যান্সগুলো টাপলের মতোই যে আপনি সেগুলোকে তাদের পৃথক অংশে ডিস্ট্রাকচার করতে পারেন, এবং আপনি একটি . এবং তারপরে ইনডেক্স ব্যবহার করে একটি পৃথক মান অ্যাক্সেস করতে পারেন। টাপলের মতো নয়, টাপল স্ট্রাকটগুলোর ক্ষেত্রে আপনাকে struct-এর টাইপের নাম দিতে হবে যখন আপনি সেগুলোকে ডিস্ট্রাকচার করবেন। উদাহরণস্বরূপ, origin পয়েন্টের মানগুলোকে x, y, এবং z নামের ভ্যারিয়েবলে ডিস্ট্রাকচার করতে আমরা let Point(x, y, z) = origin; লিখব।

কোনো ফিল্ড ছাড়া ইউনিট-লাইক স্ট্রাকট

আপনি এমন structও ডিফাইন করতে পারেন যার কোনো ফিল্ড নেই! এগুলোকে ইউনিট-লাইক স্ট্রাকট (unit-like structs) বলা হয় কারণ তারা ()-এর মতো আচরণ করে, যা আমরা "টাপল টাইপ" বিভাগে উল্লেখ করেছি। ইউনিট-লাইক স্ট্রাকটগুলো দরকারী হতে পারে যখন আপনার কোনো টাইপের উপর একটি ট্রেইট ইমপ্লিমেন্ট করতে হবে কিন্তু আপনার কাছে এমন কোনো ডেটা নেই যা আপনি টাইপের মধ্যে সংরক্ষণ করতে চান। আমরা অধ্যায় ১০-এ ট্রেইট নিয়ে আলোচনা করব। এখানে AlwaysEqual নামে একটি ইউনিট স্ট্রাকট ঘোষণা এবং ইনস্ট্যানশিয়েট করার একটি উদাহরণ দেওয়া হলো:

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

AlwaysEqual ডিফাইন করতে, আমরা struct কীওয়ার্ড, যে নামটি আমরা চাই, এবং তারপর একটি সেমিকোলন ব্যবহার করি। কার্লি ব্র্যাকেট বা প্যারেন্থেসিসের প্রয়োজন নেই! তারপর আমরা subject ভ্যারিয়েবলে AlwaysEqual-এর একটি ইনস্ট্যান্স পেতে পারি একই ভাবে: আমরা যে নামটি ডিফাইন করেছি তা ব্যবহার করে, কোনো কার্লি ব্র্যাকেট বা প্যারেন্থেসিস ছাড়াই। কল্পনা করুন যে পরে আমরা এই টাইপের জন্য এমন আচরণ ইমপ্লিমেন্ট করব যাতে AlwaysEqual-এর প্রতিটি ইনস্ট্যান্স সবসময় অন্য যেকোনো টাইপের প্রতিটি ইনস্ট্যান্সের সমান হয়, সম্ভবত পরীক্ষার উদ্দেশ্যে একটি পরিচিত ফলাফল পাওয়ার জন্য। সেই আচরণ ইমপ্লিমেন্ট করার জন্য আমাদের কোনো ডেটার প্রয়োজন হবে না! আপনি অধ্যায় ১০-এ দেখবেন কীভাবে ট্রেইট ডিফাইন করতে হয় এবং সেগুলোকে যেকোনো টাইপের উপর ইমপ্লিমেন্ট করতে হয়, যার মধ্যে ইউনিট-লাইক স্ট্রাকটও রয়েছে।

স্ট্রাকট ডেটার মালিকানা (Ownership of Struct Data)

তালিকা ৫-১ এর User struct সংজ্ঞায়, আমরা &str স্ট্রিং স্লাইস টাইপের পরিবর্তে ওনড (owned) String টাইপ ব্যবহার করেছি। এটি একটি ইচ্ছাকৃত পছন্দ কারণ আমরা চাই এই struct-এর প্রতিটি ইনস্ট্যান্স তার সমস্ত ডেটার মালিক হোক এবং সেই ডেটা পুরো struct-টি বৈধ থাকা পর্যন্ত বৈধ থাকুক।

struct-এর পক্ষে অন্য কারো মালিকানাধীন ডেটার রেফারেন্স সংরক্ষণ করাও সম্ভব, কিন্তু তা করার জন্য লাইফটাইম (lifetimes) ব্যবহার করতে হয়, যা রাস্টের একটি বৈশিষ্ট্য এবং আমরা অধ্যায় ১০-এ আলোচনা করব। লাইফটাইম নিশ্চিত করে যে একটি struct দ্বারা রেফারেন্স করা ডেটা struct-টি বৈধ থাকা পর্যন্ত বৈধ থাকবে। ধরুন আপনি লাইফটাইম নির্দিষ্ট না করে একটি struct-এ একটি রেফারেন্স সংরক্ষণ করার চেষ্টা করছেন, যেমনটি নিচে দেখানো হলো; এটি কাজ করবে না:

struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: "someusername123",
        email: "someone@example.com",
        sign_in_count: 1,
    };
}

কম্পাইলার অভিযোগ করবে যে তার লাইফটাইম স্পেসিফায়ার প্রয়োজন:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     username: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 ~     username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 |     username: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` (bin "structs") due to 2 previous errors

অধ্যায় ১০-এ, আমরা আলোচনা করব কীভাবে এই এররগুলো ঠিক করতে হয় যাতে আপনি struct-এ রেফারেন্স সংরক্ষণ করতে পারেন, কিন্তু আপাতত, আমরা এই ধরনের এররগুলো &str-এর মতো রেফারেন্সের পরিবর্তে String-এর মতো ওনড টাইপ ব্যবহার করে ঠিক করব।

struct ব্যবহার করে একটি উদাহরণ প্রোগ্রাম

আমরা কখন struct ব্যবহার করতে চাই তা বোঝার জন্য, আসুন একটি প্রোগ্রাম লিখি যা একটি আয়তক্ষেত্রের ক্ষেত্রফল গণনা করে। আমরা প্রথমে একক ভ্যারিয়েবল ব্যবহার করে শুরু করব, এবং তারপর প্রোগ্রামটিকে রিফ্যাক্টর (refactor) করে struct ব্যবহার করব।

আসুন কার্গো (Cargo) দিয়ে rectangles নামে একটি নতুন বাইনারি প্রজেক্ট তৈরি করি যা পিক্সেল এককে একটি আয়তক্ষেত্রের প্রস্থ এবং উচ্চতা নিয়ে আয়তক্ষেত্রটির ক্ষেত্রফল গণনা করবে। তালিকা ৫-৮ আমাদের প্রজেক্টের src/main.rs ফাইলে ঠিক এটি করার একটি সংক্ষিপ্ত প্রোগ্রাম দেখাচ্ছে।

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

এখন, cargo run ব্যবহার করে এই প্রোগ্রামটি চালান:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.

এই কোডটি প্রতিটি ডাইমেনশন (dimension) দিয়ে area ফাংশনটিকে কল করে আয়তক্ষেত্রের ক্ষেত্রফল বের করতে সফল হয়েছে, কিন্তু এই কোডটিকে আরও স্পষ্ট এবং পাঠযোগ্য করার জন্য আমরা আরও অনেক কিছু করতে পারি।

এই কোডের সমস্যাটি area ফাংশনের সিগনেচারে স্পষ্ট:

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

area ফাংশনটির কাজ একটি আয়তক্ষেত্রের ক্ষেত্রফল গণনা করা, কিন্তু আমরা যে ফাংশনটি লিখেছি তার দুটি প্যারামিটার রয়েছে, এবং আমাদের প্রোগ্রামের কোথাও এটা স্পষ্ট নয় যে এই প্যারামিটারগুলো সম্পর্কিত। প্রস্থ এবং উচ্চতাকে একসাথে গ্রুপ করা আরও পাঠযোগ্য এবং পরিচালনাযোগ্য হবে। অধ্যায় ৩ এর "টাপল টাইপ" বিভাগে আমরা এটি করার একটি উপায় নিয়ে ইতিমধ্যে আলোচনা করেছি: টাপল (tuples) ব্যবহার করে।

টাপল দিয়ে রিফ্যাক্টরিং (Refactoring with Tuples)

তালিকা ৫-৯ আমাদের প্রোগ্রামের আরেকটি সংস্করণ দেখাচ্ছে যা টাপল ব্যবহার করে।

fn main() {
    let rect1 = (30, 50);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}

একদিক থেকে, এই প্রোগ্রামটি ভালো। টাপল আমাদের কিছুটা গঠন যোগ করতে দেয়, এবং আমরা এখন মাত্র একটি আর্গুমেন্ট পাস করছি। কিন্তু অন্যদিক থেকে, এই সংস্করণটি কম স্পষ্ট: টাপল তার উপাদানগুলোর নাম দেয় না, তাই আমাদের টাপলের অংশগুলোতে ইনডেক্স ব্যবহার করতে হয়, যা আমাদের গণনাকে কম স্পষ্ট করে তোলে।

ক্ষেত্রফল গণনার জন্য প্রস্থ এবং উচ্চতা গুলিয়ে ফেললে কোনো সমস্যা হবে না, কিন্তু যদি আমরা স্ক্রিনে আয়তক্ষেত্রটি আঁকতে চাই, তবে এটি গুরুত্বপূর্ণ হবে! আমাদের মনে রাখতে হবে যে width হলো টাপল ইনডেক্স 0 এবং height হলো টাপল ইনডেক্স 1। অন্য কেউ যদি আমাদের কোড ব্যবহার করে, তবে তার জন্য এটি বোঝা এবং মনে রাখা আরও কঠিন হবে। যেহেতু আমরা আমাদের কোডে ডেটার অর্থ প্রকাশ করিনি, তাই এখন ভুল হওয়ার সম্ভাবনা বেড়ে গেছে।

struct দিয়ে রিফ্যাক্টরিং: আরও অর্থ যোগ করা

আমরা ডেটাকে লেবেল দিয়ে অর্থ যোগ করার জন্য struct ব্যবহার করি। আমরা যে টাপলটি ব্যবহার করছি সেটিকে একটি struct-এ রূপান্তর করতে পারি, যেখানে পুরোটার জন্য একটি নাম এবং অংশগুলোর জন্যও নাম থাকবে, যেমনটি তালিকা ৫-১০-এ দেখানো হয়েছে।

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

এখানে, আমরা একটি struct ডিফাইন করেছি এবং এর নাম দিয়েছি Rectangle। কার্লি ব্র্যাকেটের ভিতরে, আমরা ফিল্ডগুলোকে width এবং height হিসাবে ডিফাইন করেছি, যার উভয়েরই টাইপ u32। তারপর, main ফাংশনে, আমরা Rectangle-এর একটি নির্দিষ্ট ইনস্ট্যান্স তৈরি করেছি যার প্রস্থ 30 এবং উচ্চতা 50।

আমাদের area ফাংশনটি এখন একটি প্যারামিটার দিয়ে ডিফাইন করা হয়েছে, যার নাম আমরা দিয়েছি rectangle, এবং এর টাইপ হলো একটি Rectangle struct ইনস্ট্যান্সের একটি অপরিবর্তনীয় ধার (immutable borrow)। অধ্যায় ৪-এ যেমন উল্লেখ করা হয়েছে, আমরা struct-টির মালিকানা নেওয়ার পরিবর্তে এটি ধার করতে চাই। এইভাবে, main তার মালিকানা ধরে রাখে এবং rect1 ব্যবহার করা চালিয়ে যেতে পারে, যে কারণে আমরা ফাংশন সিগনেচারে এবং যেখানে ফাংশনটি কল করি সেখানে & ব্যবহার করি।

area ফাংশনটি Rectangle ইনস্ট্যান্সের width এবং height ফিল্ডগুলো অ্যাক্সেস করে (উল্লেখ্য যে একটি ধার করা struct ইনস্ট্যান্সের ফিল্ড অ্যাক্সেস করলে ফিল্ডের মানগুলো মুভ (move) হয় না, যে কারণে আপনি প্রায়শই struct-এর ধার দেখতে পাবেন)। আমাদের area-এর ফাংশন সিগনেচার এখন ঠিক তাই বলছে যা আমরা বলতে চাই: Rectangle-এর ক্ষেত্রফল গণনা করুন, এর width এবং height ফিল্ড ব্যবহার করে। এটি প্রকাশ করে যে প্রস্থ এবং উচ্চতা একে অপরের সাথে সম্পর্কিত, এবং এটি টাপল ইনডেক্স মান 0 এবং 1 ব্যবহার করার পরিবর্তে মানগুলোকে বর্ণনামূলক নাম দেয়। এটি স্পষ্টতার দিক থেকে একটি বড় সুবিধা।

ডিরাইভড ট্রেইট দিয়ে দরকারী কার্যকারিতা যোগ করা (Adding Useful Functionality with Derived Traits)

আমাদের প্রোগ্রাম ডিবাগ করার সময় Rectangle-এর একটি ইনস্ট্যান্স প্রিন্ট করতে পারা এবং এর সমস্ত ফিল্ডের মান দেখতে পারা দরকারী হবে। তালিকা ৫-১১ পূর্ববর্তী অধ্যায়গুলোতে আমরা যেভাবে println! ম্যাক্রো ব্যবহার করেছি, সেভাবে ব্যবহার করার চেষ্টা করে। তবে এটি কাজ করবে না।

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1}");
}

যখন আমরা এই কোডটি কম্পাইল করি, আমরা এই মূল বার্তা সহ একটি এরর পাই:

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

println! ম্যাক্রো অনেক ধরণের ফরম্যাটিং করতে পারে, এবং ডিফল্টভাবে, কার্লি ব্র্যাকেটগুলো println!-কে Display নামে পরিচিত একটি ফরম্যাটিং ব্যবহার করতে বলে: যা সরাসরি এন্ড-ইউজারের ব্যবহারের জন্য আউটপুট। আমরা এখন পর্যন্ত যে প্রিমিটিভ টাইপগুলো দেখেছি সেগুলো ডিফল্টভাবে Display ইমপ্লিমেন্ট করে কারণ একজন ব্যবহারকারীকে 1 বা অন্য কোনো প্রিমিটিভ টাইপ দেখানোর একটিই উপায় আছে। কিন্তু struct-এর ক্ষেত্রে, println! আউটপুট কীভাবে ফরম্যাট করবে তা কম স্পষ্ট কারণ আরও অনেক প্রদর্শনের সম্ভাবনা রয়েছে: আপনি কি কমা চান কি না? আপনি কি কার্লি ব্র্যাকেট প্রিন্ট করতে চান? সমস্ত ফিল্ড কি দেখানো উচিত? এই অস্পষ্টতার কারণে, রাস্ট অনুমান করার চেষ্টা করে না আমরা কী চাই, এবং struct-এর println! এবং {} প্লেসহোল্ডারের সাথে ব্যবহারের জন্য Display-এর কোনো সরবরাহ করা ইমপ্লিমেন্টেশন নেই।

যদি আমরা এররগুলো পড়া চালিয়ে যাই, আমরা এই সহায়ক নোটটি খুঁজে পাব:

   = help: the trait `std::fmt::Display` is not implemented for `Rectangle`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead```

চলুন চেষ্টা করি! `println!` ম্যাক্রো কলটি এখন `println!("rect1 is {rect1:?}");`-এর মতো দেখাবে। কার্লি ব্র্যাকেটের ভিতরে স্পেসিফায়ার `:?` রাখলে `println!`-কে বলা হয় আমরা `Debug` নামে একটি আউটপুট ফরম্যাট ব্যবহার করতে চাই। `Debug` ট্রেইটটি আমাদের `struct`-কে এমনভাবে প্রিন্ট করতে সক্ষম করে যা ডেভেলপারদের জন্য দরকারী যাতে আমরা আমাদের কোড ডিবাগ করার সময় এর মান দেখতে পারি।

এই পরিবর্তন সহ কোডটি কম্পাইল করুন। ধুর! আমরা এখনও একটি এরর পাচ্ছি:

```text
error[E0277]: `Rectangle` doesn't implement `Debug````

কিন্তু আবারও, কম্পাইলার আমাদের একটি সহায়ক নোট দেয়:

```text
   = help: the trait `Debug` is not implemented for `Rectangle`
   = note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`

রাস্ট ডিবাগিং তথ্য প্রিন্ট করার জন্য কার্যকারিতা অন্তর্ভুক্ত করে, কিন্তু আমাদের struct-এর জন্য সেই কার্যকারিতা উপলব্ধ করতে স্পষ্টভাবে অপ্ট-ইন করতে হবে। এটি করার জন্য, আমরা struct সংজ্ঞার ঠিক আগে #[derive(Debug)] অ্যাট্রিবিউটটি যোগ করি, যেমনটি তালিকা ৫-১২-এ দেখানো হয়েছে।

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1:?}");
}

এখন যখন আমরা প্রোগ্রামটি চালাই, আমরা কোনো এরর পাব না, এবং আমরা নিম্নলিখিত আউটপুটটি দেখব:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }

সুন্দর! এটি সবচেয়ে সুন্দর আউটপুট নয়, তবে এটি এই ইনস্ট্যান্সের জন্য সমস্ত ফিল্ডের মান দেখায়, যা ডিবাগিংয়ের সময় অবশ্যই সাহায্য করবে। যখন আমাদের বড় struct থাকে, তখন এমন আউটপুট থাকা দরকারী যা পড়া একটু সহজ; সেই ক্ষেত্রে, আমরা println! স্ট্রিং-এ {:?} এর পরিবর্তে {:#?} ব্যবহার করতে পারি। এই উদাহরণে, {:#?} স্টাইল ব্যবহার করলে নিম্নলিখিত আউটপুটটি আসবে:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle {
    width: 30,
    height: 50,
}

Debug ফরম্যাট ব্যবহার করে একটি মান প্রিন্ট করার আরেকটি উপায় হলো dbg! ম্যাক্রো ব্যবহার করা, যা একটি এক্সপ্রেশনের মালিকানা নেয় (println!-এর বিপরীতে, যা একটি রেফারেন্স নেয়), আপনার কোডে সেই dbg! ম্যাক্রো কলটি কোথায় ঘটেছে তার ফাইল এবং লাইন নম্বর প্রিন্ট করে এবং সেই এক্সপ্রেশনের ফলস্বরূপ মান সহ, এবং মানের মালিকানা ফেরত দেয়।

দ্রষ্টব্য: dbg! ম্যাক্রো কল করা স্ট্যান্ডার্ড এরর কনসোল স্ট্রিমে (stderr) প্রিন্ট করে, println!-এর বিপরীতে, যা স্ট্যান্ডার্ড আউটপুট কনসোল স্ট্রিমে (stdout) প্রিন্ট করে। আমরা অধ্যায় ১২-এর "স্ট্যান্ডার্ড আউটপুটের পরিবর্তে স্ট্যান্ডার্ড এররে এরর বার্তা লেখা" বিভাগে stderr এবং stdout সম্পর্কে আরও কথা বলব।

এখানে একটি উদাহরণ যেখানে আমরা width ফিল্ডে নির্ধারিত মান এবং rect1-এর পুরো struct-এর মানে আগ্রহী:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

আমরা 30 * scale এক্সপ্রেশনের চারপাশে dbg! রাখতে পারি এবং, যেহেতু dbg! এক্সপ্রেশনের মানের মালিকানা ফেরত দেয়, width ফিল্ডটি একই মান পাবে যেন আমাদের সেখানে dbg! কল ছিল না। আমরা চাই না dbg! rect1-এর মালিকানা নিক, তাই আমরা পরবর্তী কলে rect1-এর একটি রেফারেন্স ব্যবহার করি। এই উদাহরণের আউটপুটটি দেখতে এইরকম:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * scale = 60
[src/main.rs:14:5] &rect1 = Rectangle {
    width: 60,
    height: 50,
}

আমরা দেখতে পাচ্ছি প্রথম আউটপুটটি src/main.rs লাইন ১০ থেকে এসেছে যেখানে আমরা 30 * scale এক্সপ্রেশনটি ডিবাগ করছি, এবং এর ফলস্বরূপ মান 60 (পূর্ণসংখ্যার জন্য ইমপ্লিমেন্ট করা Debug ফরম্যাটিং হলো শুধুমাত্র তাদের মান প্রিন্ট করা)। src/main.rs এর ১৪ নং লাইনের dbg! কলটি &rect1-এর মান আউটপুট করে, যা Rectangle struct। এই আউটপুটটি Rectangle টাইপের সুন্দর Debug ফরম্যাটিং ব্যবহার করে। dbg! ম্যাক্রোটি খুব সহায়ক হতে পারে যখন আপনি আপনার কোড কী করছে তা বোঝার চেষ্টা করছেন!

Debug ট্রেইট ছাড়াও, রাস্ট আমাদের derive অ্যাট্রিবিউট দিয়ে ব্যবহারের জন্য বেশ কয়েকটি ট্রেইট সরবরাহ করেছে যা আমাদের কাস্টম টাইপগুলোতে দরকারী আচরণ যোগ করতে পারে। সেই ট্রেইট এবং তাদের আচরণগুলো পরিশিষ্ট C-তে তালিকাভুক্ত করা হয়েছে। আমরা কাস্টম আচরণ সহ এই ট্রেইটগুলো কীভাবে ইমপ্লিমেন্ট করতে হয় এবং কীভাবে আপনার নিজস্ব ট্রেইট তৈরি করতে হয় তা অধ্যায় ১০-এ আলোচনা করব। derive ছাড়াও আরও অনেক অ্যাট্রিবিউট রয়েছে; আরও তথ্যের জন্য, রাস্ট রেফারেন্সের "অ্যাট্রিবিউটস" বিভাগটি দেখুন।

আমাদের area ফাংশনটি খুব নির্দিষ্ট: এটি শুধুমাত্র আয়তক্ষেত্রের ক্ষেত্রফল গণনা করে। এই আচরণটিকে আমাদের Rectangle struct-এর সাথে আরও ঘনিষ্ঠভাবে যুক্ত করা সহায়ক হবে কারণ এটি অন্য কোনো টাইপের সাথে কাজ করবে না। আসুন দেখি কীভাবে আমরা area ফাংশনটিকে আমাদের Rectangle টাইপে ডিফাইন করা একটি area মেথডে পরিণত করে এই কোডটিকে রিফ্যাক্টর করা চালিয়ে যেতে পারি।

মেথড সিনট্যাক্স (Method Syntax)

মেথড (Methods) অনেকটা ফাংশনের মতোই: আমরা fn কীওয়ার্ড এবং একটি নাম দিয়ে এগুলো ডিক্লেয়ার করি, এগুলোর প্যারামিটার এবং একটি রিটার্ন ভ্যালু থাকতে পারে, এবং এগুলোর মধ্যে কিছু কোড থাকে যা অন্য কোথাও থেকে মেথডটি কল করা হলে রান হয়। ফাংশনের সাথে এর পার্থক্য হলো, মেথডগুলো একটি struct (অথবা একটি enum বা একটি trait অবজেক্ট, যা আমরা যথাক্রমে অধ্যায় ৬ এবং অধ্যায় ১৮-এ আলোচনা করব) এর কনটেক্সটে ডিফাইন করা হয়, এবং তাদের প্রথম প্যারামিটার সবসময় self হয়, যা struct-এর সেই ইনস্ট্যান্সটিকে প্রতিনিধিত্ব করে যার উপর মেথডটি কল করা হচ্ছে।

মেথড ডিফাইন করা (Defining Methods)

আসুন area ফাংশনটিকে পরিবর্তন করি, যেটি একটি Rectangle ইনস্ট্যান্সকে প্যারামিটার হিসেবে নেয়, এবং এর পরিবর্তে Rectangle struct-এর উপর ডিফাইন করা একটি area মেথড তৈরি করি, যেমনটি তালিকা ৫-১৩-এ দেখানো হয়েছে।

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

Rectangle-এর কনটেক্সটে ফাংশনটি ডিফাইন করার জন্য, আমরা Rectangle-এর জন্য একটি impl (implementation) ব্লক শুরু করি। এই impl ব্লকের মধ্যে থাকা সবকিছু Rectangle টাইপের সাথে যুক্ত থাকবে। তারপর আমরা area ফাংশনটিকে impl কার্লি ব্র্যাকেটের মধ্যে নিয়ে যাই এবং সিগনেচারে এবং বডির সর্বত্র প্রথম (এবং এই ক্ষেত্রে, একমাত্র) প্যারামিটারটিকে self এ পরিবর্তন করি। main ফাংশনে, যেখানে আমরা area ফাংশন কল করেছিলাম এবং rect1 কে আর্গুমেন্ট হিসাবে পাস করেছিলাম, তার পরিবর্তে আমরা আমাদের Rectangle ইনস্ট্যান্সের উপর area মেথড কল করার জন্য মেথড সিনট্যাক্স (method syntax) ব্যবহার করতে পারি। মেথড সিনট্যাক্স একটি ইনস্ট্যান্সের পরে বসে: আমরা একটি ডট এবং তারপরে মেথডের নাম, প্যারেন্থেসিস এবং যেকোনো আর্গুমেন্ট যোগ করি।

area-এর সিগনেচারে, আমরা rectangle: &Rectangle এর পরিবর্তে &self ব্যবহার করি। &self আসলে self: &Self-এর সংক্ষিপ্ত রূপ। একটি impl ব্লকের মধ্যে, Self টাইপটি সেই টাইপের একটি অ্যালিয়াস (alias) যার জন্য impl ব্লকটি তৈরি করা হয়েছে। মেথডগুলোর প্রথম প্যারামিটার হিসাবে self নামের একটি Self টাইপের প্যারামিটার থাকতে হয়, তাই রাস্ট আপনাকে প্রথম প্যারামিটারের স্থানে শুধুমাত্র self নামটি দিয়ে এটিকে সংক্ষিপ্ত করার অনুমতি দেয়। মনে রাখবেন যে আমাদের এখনও self শর্টহ্যান্ডের আগে & ব্যবহার করতে হবে এটি বোঝাতে যে এই মেথডটি Self ইনস্ট্যান্সটিকে ধার (borrow) করে, ঠিক যেমনটি আমরা rectangle: &Rectangle-এ করেছিলাম। মেথডগুলো self-এর মালিকানা নিতে পারে, self-কে অপরিবর্তনীয়ভাবে ধার করতে পারে, যেমনটি আমরা এখানে করেছি, অথবা self-কে পরিবর্তনীয়ভাবে ধার করতে পারে, ঠিক যেমনটি তারা অন্য যেকোনো প্যারামিটারের ক্ষেত্রে পারে।

আমরা এখানে &self বেছে নিয়েছি একই কারণে যে কারণে আমরা ফাংশন সংস্করণে &Rectangle ব্যবহার করেছিলাম: আমরা মালিকানা নিতে চাই না, এবং আমরা কেবল struct-এর ডেটা পড়তে চাই, এতে লিখতে চাই না। যদি আমরা যে ইনস্ট্যান্সের উপর মেথডটি কল করেছি সেটিকে মেথডের কাজের অংশ হিসাবে পরিবর্তন করতে চাইতাম, তাহলে আমরা প্রথম প্যারামিটার হিসাবে &mut self ব্যবহার করতাম। self-কে প্রথম প্যারামিটার হিসাবে ব্যবহার করে ইনস্ট্যান্সের মালিকানা নেওয়া একটি মেথড বিরল; এই কৌশলটি সাধারণত ব্যবহৃত হয় যখন মেথডটি self-কে অন্য কিছুতে রূপান্তরিত করে এবং আপনি চান যে রূপান্তরের পরে কলার মূল ইনস্ট্যান্সটি ব্যবহার করা থেকে বিরত থাকুক।

মেথড সিনট্যাক্স সরবরাহ করা এবং প্রতিটি মেথডের সিগনেচারে self-এর টাইপ পুনরাবৃত্তি না করার পাশাপাশি, ফাংশনের পরিবর্তে মেথড ব্যবহারের মূল কারণ হলো অর্গানাইজেশন বা সংগঠন। আমরা একটি টাইপের ইনস্ট্যান্সের সাথে যা যা করা যায় তার সবকিছু একটি impl ব্লকের মধ্যে রেখেছি, যাতে আমাদের কোডের ভবিষ্যতের ব্যবহারকারীদেরকে আমাদের সরবরাহ করা লাইব্রেরির বিভিন্ন জায়গায় Rectangle-এর ক্ষমতা খুঁজতে না হয়।

মনে রাখবেন যে আমরা একটি মেথডকে struct-এর একটি ফিল্ডের সমান নাম দিতে পারি। উদাহরণস্বরূপ, আমরা Rectangle-এর উপর width নামে একটি মেথড ডিফাইন করতে পারি:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn width(&self) -> bool {
        self.width > 0
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    if rect1.width() {
        println!("The rectangle has a nonzero width; it is {}", rect1.width);
    }
}

এখানে, আমরা width মেথডটিকে true রিটার্ন করার জন্য তৈরি করছি যদি ইনস্ট্যান্সের width ফিল্ডের মান 0-এর চেয়ে বড় হয় এবং false যদি মান 0 হয়: আমরা একই নামের একটি মেথডের মধ্যে একটি ফিল্ড যেকোনো উদ্দেশ্যে ব্যবহার করতে পারি। main-এ, যখন আমরা rect1.width-এর পরে প্যারেন্থেসিস ব্যবহার করি, রাস্ট জানে যে আমরা width মেথডটির কথা বলছি। যখন আমরা প্যারেন্থেসিস ব্যবহার করি না, রাস্ট জানে যে আমরা width ফিল্ডটির কথা বলছি।

প্রায়শই, কিন্তু সবসময় নয়, যখন আমরা একটি মেথডকে একটি ফিল্ডের সমান নাম দিই তখন আমরা চাই এটি শুধুমাত্র ফিল্ডের মান রিটার্ন করুক এবং অন্য কিছু না করুক। এই ধরনের মেথডকে গেটার (getters) বলা হয়, এবং রাস্ট অন্য কিছু ভাষার মতো struct ফিল্ডের জন্য এগুলো স্বয়ংক্রিয়ভাবে ইমপ্লিমেন্ট করে না। গেটারগুলো দরকারী কারণ আপনি ফিল্ডটিকে প্রাইভেট কিন্তু মেথডটিকে পাবলিক করতে পারেন, এবং এইভাবে টাইপের পাবলিক API-এর অংশ হিসাবে সেই ফিল্ডে শুধুমাত্র-পড়ার (read-only) অ্যাক্সেস সক্ষম করতে পারেন। আমরা পাবলিক এবং প্রাইভেট কী এবং কীভাবে একটি ফিল্ড বা মেথডকে পাবলিক বা প্রাইভেট হিসাবে চিহ্নিত করতে হয় তা অধ্যায় ৭-এ আলোচনা করব।

-> অপারেটরটি কোথায়?

C এবং C++ এ, মেথড কল করার জন্য দুটি ভিন্ন অপারেটর ব্যবহৃত হয়: আপনি . ব্যবহার করেন যদি আপনি সরাসরি অবজেক্টের উপর একটি মেথড কল করেন এবং -> ব্যবহার করেন যদি আপনি অবজেক্টের একটি পয়েন্টারের উপর মেথড কল করেন এবং প্রথমে পয়েন্টারটিকে ডি-রেফারেন্স করতে হয়। অন্য কথায়, যদি object একটি পয়েন্টার হয়, object->something() অনেকটা (*object).something()-এর মতো।

রাস্টের -> অপারেটরের সমতুল্য কিছু নেই; এর পরিবর্তে, রাস্টের একটি বৈশিষ্ট্য রয়েছে যার নাম স্বয়ংক্রিয় রেফারেন্সিং এবং ডি-রেফারেন্সিং (automatic referencing and dereferencing)। মেথড কল করা রাস্টের কয়েকটি জায়গার মধ্যে একটি যেখানে এই আচরণ রয়েছে।

এটি যেভাবে কাজ করে: যখন আপনি object.something() দিয়ে একটি মেথড কল করেন, রাস্ট স্বয়ংক্রিয়ভাবে &, &mut, বা * যোগ করে দেয় যাতে object মেথডের সিগনেচারের সাথে মেলে। অন্য কথায়, নিম্নলিখিতগুলো একই:

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
   fn distance(&self, other: &Point) -> f64 {
       let x_squared = f64::powi(other.x - self.x, 2);
       let y_squared = f64::powi(other.y - self.y, 2);

       f64::sqrt(x_squared + y_squared)
   }
}
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.distance(&p2);
(&p1).distance(&p2);
}

প্রথমটি দেখতে অনেক পরিষ্কার। এই স্বয়ংক্রিয় রেফারেন্সিং আচরণটি কাজ করে কারণ মেথডগুলোর একটি স্পষ্ট রিসিভার (receiver) আছে—self-এর টাইপ। রিসিভার এবং একটি মেথডের নাম দেওয়া হলে, রাস্ট নির্দিষ্টভাবে বের করতে পারে যে মেথডটি পড়ছে (&self), পরিবর্তন করছে (&mut self), বা ব্যবহার করে ফেলছে (self)। রাস্ট যে মেথড রিসিভারের জন্য ধার করাকে উহ্য (implicit) করে তোলে তা বাস্তবে মালিকানাকে অর্গোনমিক (ergonomic) করার একটি বড় অংশ।

একাধিক প্যারামিটার সহ মেথড (Methods with More Parameters)

আসুন Rectangle struct-এর উপর একটি দ্বিতীয় মেথড ইমপ্লিমেন্ট করে মেথড ব্যবহার করার অনুশীলন করি। এবার আমরা চাই Rectangle-এর একটি ইনস্ট্যান্স Rectangle-এর আরেকটি ইনস্ট্যান্স নিক এবং true রিটার্ন করুক যদি দ্বিতীয় Rectangle-টি self-এর (প্রথম Rectangle) মধ্যে সম্পূর্ণরূপে ফিট করতে পারে; অন্যথায়, এটি false রিটার্ন করবে। অর্থাৎ, একবার আমরা can_hold মেথডটি ডিফাইন করে ফেলার পর, আমরা তালিকা ৫-১৪-এ দেখানো প্রোগ্রামটি লিখতে চাই।

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

প্রত্যাশিত আউটপুট নিম্নলিখিতটির মতো হবে কারণ rect2-এর উভয় ডাইমেনশন rect1-এর ডাইমেনশনের চেয়ে ছোট, কিন্তু rect3 rect1-এর চেয়ে চওড়া:

Can rect1 hold rect2? true
Can rect1 hold rect3? false

আমরা জানি আমরা একটি মেথড ডিফাইন করতে চাই, তাই এটি impl Rectangle ব্লকের মধ্যে থাকবে। মেথডের নাম হবে can_hold, এবং এটি অন্য একটি Rectangle-এর একটি অপরিবর্তনীয় ধার (immutable borrow) প্যারামিটার হিসাবে নেবে। আমরা প্যারামিটারের টাইপ কী হবে তা মেথড কল করা কোডটি দেখে বলতে পারি: rect1.can_hold(&rect2) &rect2 পাস করে, যা rect2, একটি Rectangle ইনস্ট্যান্সের একটি অপরিবর্তনীয় ধার। এটি যৌক্তিক কারণ আমাদের কেবল rect2 পড়তে হবে (লেখার পরিবর্তে, যার জন্য আমাদের একটি পরিবর্তনযোগ্য ধার প্রয়োজন হতো), এবং আমরা চাই main rect2-এর মালিকানা ধরে রাখুক যাতে আমরা can_hold মেথড কল করার পরেও এটি আবার ব্যবহার করতে পারি। can_hold-এর রিটার্ন ভ্যালু একটি বুলিয়ান হবে, এবং ইমপ্লিমেন্টেশনটি পরীক্ষা করবে যে self-এর প্রস্থ এবং উচ্চতা অন্য Rectangle-এর প্রস্থ এবং উচ্চতার চেয়ে বড় কিনা। আসুন নতুন can_hold মেথডটি তালিকা ৫-১৩ থেকে impl ব্লকে যোগ করি, যা তালিকা ৫-১৫-এ দেখানো হয়েছে।

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

যখন আমরা এই কোডটি তালিকা ৫-১৪-এর main ফাংশন দিয়ে চালাই, আমরা আমাদের কাঙ্ক্ষিত আউটপুট পাব। মেথডগুলো self প্যারামিটারের পরে একাধিক প্যারামিটার নিতে পারে যা আমরা সিগনেচারে যোগ করি, এবং সেই প্যারামিটারগুলো ফাংশনের প্যারামিটারের মতোই কাজ করে।

অ্যাসোসিয়েটেড ফাংশন (Associated Functions)

একটি impl ব্লকের মধ্যে ডিফাইন করা সমস্ত ফাংশনকে অ্যাসোসিয়েটেড ফাংশন (associated functions) বলা হয় কারণ সেগুলো impl-এর পরে নাম দেওয়া টাইপের সাথে যুক্ত। আমরা এমন অ্যাসোসিয়েটেড ফাংশন ডিফাইন করতে পারি যেগুলোর প্রথম প্যারামিটার self নয় (এবং এইভাবে সেগুলো মেথড নয়) কারণ সেগুলোর সাথে কাজ করার জন্য টাইপের একটি ইনস্ট্যান্সের প্রয়োজন হয় না। আমরা ইতিমধ্যে এই ধরনের একটি ফাংশন ব্যবহার করেছি: String::from ফাংশন যা String টাইপের উপর ডিফাইন করা আছে।

যেসব অ্যাসোসিয়েটেড ফাংশন মেথড নয় সেগুলো প্রায়শই কনস্ট্রাক্টর (constructors) হিসাবে ব্যবহৃত হয় যা struct-এর একটি নতুন ইনস্ট্যান্স রিটার্ন করবে। এগুলোকে প্রায়শই new বলা হয়, কিন্তু new কোনো বিশেষ নাম নয় এবং এটি ভাষায় বিল্ট-ইন নয়। উদাহরণস্বরূপ, আমরা square নামে একটি অ্যাসোসিয়েটেড ফাংশন সরবরাহ করতে পারি যা একটি ডাইমেনশন প্যারামিটার নেবে এবং সেটিকে প্রস্থ এবং উচ্চতা উভয় হিসাবে ব্যবহার করবে, এইভাবে একটি বর্গক্ষেত্র Rectangle তৈরি করা সহজ করে তুলবে, একই মান দুবার নির্দিষ্ট করার পরিবর্তে:

Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let sq = Rectangle::square(3);
}

রিটার্ন টাইপ এবং ফাংশনের বডিতে Self কীওয়ার্ডগুলো সেই টাইপের অ্যালিয়াস যা impl কীওয়ার্ডের পরে আসে, যা এই ক্ষেত্রে Rectangle।

এই অ্যাসোসিয়েটেড ফাংশনটি কল করার জন্য, আমরা struct-এর নামের সাথে :: সিনট্যাক্স ব্যবহার করি; let sq = Rectangle::square(3); একটি উদাহরণ। এই ফাংশনটি struct দ্বারা নেমস্পেসড (namespaced) হয়: :: সিনট্যাক্সটি অ্যাসোসিয়েটেড ফাংশন এবং মডিউল দ্বারা তৈরি নেমস্পেস উভয়ের জন্যই ব্যবহৃত হয়। আমরা অধ্যায় ৭-এ মডিউল নিয়ে আলোচনা করব।

একাধিক impl ব্লক (Multiple impl Blocks)

প্রতিটি struct-এর একাধিক impl ব্লক থাকতে পারে। উদাহরণস্বরূপ, তালিকা ৫-১৫ তালিকা ৫-১৬-এ দেখানো কোডের সমতুল্য, যেখানে প্রতিটি মেথড তার নিজস্ব impl ব্লকে রয়েছে।

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

এখানে এই মেথডগুলোকে একাধিক impl ব্লকে বিভক্ত করার কোনো কারণ নেই, তবে এটি একটি বৈধ সিনট্যাক্স। আমরা অধ্যায় ১০-এ একটি কেস দেখব যেখানে একাধিক impl ব্লক দরকারী, যেখানে আমরা জেনেরিক টাইপ এবং ট্রেইট নিয়ে আলোচনা করব।

সারসংক্ষেপ (Summary)

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

কিন্তু struct আপনার কাস্টম টাইপ তৈরি করার একমাত্র উপায় নয়: আসুন রাস্টের enum বৈশিষ্ট্যটির দিকে নজর দিই এবং আপনার টুলবক্সে আরেকটি টুল যোগ করি।

Enum এবং Pattern Matching

এই চ্যাপ্টারে আমরা enumerations, যা enums নামেও পরিচিত, তা নিয়ে আলোচনা করব। Enum ব্যবহার করে আপনি একটি type-কে তার সম্ভাব্য variants গণনা করার মাধ্যমে ডিফাইন করতে পারেন। প্রথমে, আমরা একটি enum ডিফাইন এবং ব্যবহার করে দেখব কিভাবে এটি data-র সাথে অর্থও এনকোড করতে পারে। এরপর আমরা Option নামে একটি বিশেষ প্রয়োজনীয় enum দেখব, যা প্রকাশ করে যে একটি value হয় কিছু একটা হতে পারে অথবা কিছুই না। তারপর আমরা দেখব match এক্সপ্রেশনের মাধ্যমে pattern matching ব্যবহার করে কিভাবে একটি enum-এর বিভিন্ন value-র জন্য আলাদা আলাদা কোড চালানো সহজ হয়। সবশেষে, আমরা if let কনস্ট্রাক্টটি নিয়ে আলোচনা করব, যা আপনার কোডে enum পরিচালনা করার জন্য একটি সুবিধাজনক এবং সংক্ষিপ্ত উপায়।

একটি Enum ডিফাইন করা

যেখানে struct আপনাকে সম্পর্কিত field এবং data-কে একসাথে গ্রুপ করার একটি উপায় দেয়, যেমন একটি Rectangle এর width এবং height, সেখানে enum আপনাকে বলার একটি উপায় দেয় যে একটি value একটি সম্ভাব্য সেটের মধ্যে একটি। উদাহরণস্বরূপ, আমরা বলতে পারি যে Rectangle একটি সম্ভাব্য shape-এর সেট-এর মধ্যে একটি, যার মধ্যে Circle এবং Triangle-ও রয়েছে। এটি করার জন্য, Rust আমাদের এই সম্ভাবনাগুলোকে একটি enum হিসাবে এনকোড করার অনুমতি দেয়।

আসুন আমরা এমন একটি পরিস্থিতি দেখি যা আমরা কোডে প্রকাশ করতে চাই এবং দেখি কেন এই ক্ষেত্রে struct-এর চেয়ে enum বেশি উপযোগী এবং উপযুক্ত। ধরুন আমাদের IP address নিয়ে কাজ করতে হবে। বর্তমানে, IP address-এর জন্য দুটি প্রধান standard ব্যবহৃত হয়: ভার্সন ফোর এবং ভার্সন সিক্স। যেহেতু আমাদের প্রোগ্রামে একটি IP address-এর জন্য এই দুটিই একমাত্র সম্ভাবনা, তাই আমরা সমস্ত সম্ভাব্য variant-গুলোকে enumerate বা গণনা করতে পারি, যেখান থেকে enumeration নামটি এসেছে।

যেকোনো IP address হয় ভার্সন ফোর বা ভার্সন সিক্স হতে পারে, কিন্তু একই সাথে উভয়ই হতে পারে না। IP address-এর এই বৈশিষ্ট্যটি enum ডেটা স্ট্রাকচারকে উপযুক্ত করে তোলে কারণ একটি enum value তার variant-গুলোর মধ্যে শুধুমাত্র একটি হতে পারে। ভার্সন ফোর এবং ভার্সন সিক্স উভয় address-ই এখনও মৌলিকভাবে IP address, তাই যখন কোডটি যেকোনো ধরনের IP address-এর জন্য প্রযোজ্য পরিস্থিতি পরিচালনা করে, তখন তাদের একই type হিসাবে গণ্য করা উচিত।

আমরা এই ধারণাটি কোডে প্রকাশ করতে পারি একটি IpAddrKind enum ডিফাইন করে এবং একটি IP address-এর সম্ভাব্য প্রকার V4 এবং V6-কে তালিকাভুক্ত করে। এগুলি হলো enum-এর variant:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

IpAddrKind এখন একটি কাস্টম ডেটা type যা আমরা আমাদের কোডের অন্য কোথাও ব্যবহার করতে পারি।

Enum ভ্যালু

আমরা IpAddrKind-এর দুটি variant-এর প্রত্যেকটির instance এভাবে তৈরি করতে পারি:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

লক্ষ্য করুন যে enum-এর variant-গুলো তার আইডেন্টিফায়ারের অধীনে namespaced থাকে এবং আমরা দুটিকে আলাদা করতে একটি ডাবল কোলন (::) ব্যবহার করি। এটি দরকারী কারণ এখন IpAddrKind::V4 এবং IpAddrKind::V6 উভয়ই একই type-এর: IpAddrKind। এর ফলে আমরা, উদাহরণস্বরূপ, একটি function ডিফাইন করতে পারি যা যেকোনো IpAddrKind গ্রহণ করে:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

এবং আমরা এই function-টিকে যেকোনো variant দিয়ে কল করতে পারি:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

enum ব্যবহার করার আরও সুবিধা আছে। আমাদের IP address type সম্পর্কে আরও ভাবলে দেখা যায়, এই মুহূর্তে আমাদের কাছে আসল IP address data সংরক্ষণ করার কোনো উপায় নেই; আমরা কেবল জানি এটি কোন kind বা প্রকারের। চ্যাপ্টার ৫-এ আপনি যেহেতু struct সম্পর্কে শিখেছেন, আপনি হয়তো এই সমস্যাটি struct দিয়ে সমাধান করার চেষ্টা করতে পারেন, যেমনটি লিস্টিং ৬-১ এ দেখানো হয়েছে।

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}

এখানে, আমরা একটি IpAddr struct ডিফাইন করেছি যার দুটি field আছে: একটি kind field যা IpAddrKind type-এর (আমাদের আগে ডিফাইন করা enum) এবং একটি address field যা String type-এর। আমাদের এই struct-এর দুটি instance আছে। প্রথমটি হলো home, এবং এটির kind হিসেবে IpAddrKind::V4 এবং এর সাথে সম্পর্কিত address data হিসেবে 127.0.0.1 আছে। দ্বিতীয় instance হলো loopback। এটির kind হিসেবে IpAddrKind-এর অন্য variant, V6 আছে এবং এর সাথে ::1 address সম্পর্কিত আছে। আমরা kind এবং address value-গুলোকে একসাথে বান্ডিল করতে একটি struct ব্যবহার করেছি, তাই এখন variant-টি value-এর সাথে সম্পর্কিত।

যাইহোক, শুধু একটি enum ব্যবহার করে একই ধারণা প্রকাশ করা আরও সংক্ষিপ্ত: একটি struct-এর ভিতরে enum না রেখে, আমরা সরাসরি প্রতিটি enum variant-এর মধ্যে data রাখতে পারি। IpAddr enum-এর এই নতুন সংজ্ঞাটি বলছে যে V4 এবং V6 উভয় variant-এর সাথেই String value যুক্ত থাকবে:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

আমরা সরাসরি enum-এর প্রতিটি variant-এর সাথে data সংযুক্ত করি, তাই অতিরিক্ত struct-এর কোনো প্রয়োজন নেই। এখানে, enum কিভাবে কাজ করে তার আরেকটি বিস্তারিত দিক দেখাও সহজ: আমরা যে প্রতিটি enum variant ডিফাইন করি তার নামও একটি function হয়ে যায় যা enum-এর একটি instance তৈরি করে। অর্থাৎ, IpAddr::V4() একটি function কল যা একটি String আর্গুমেন্ট নেয় এবং IpAddr type-এর একটি instance রিটার্ন করে। enum ডিফাইন করার ফলে আমরা স্বয়ংক্রিয়ভাবে এই constructor function-টি পেয়ে যাই।

struct-এর চেয়ে enum ব্যবহার করার আরেকটি সুবিধা হলো: প্রতিটি variant-এর সাথে বিভিন্ন type এবং পরিমাণের data যুক্ত থাকতে পারে। ভার্সন ফোর IP address-এ সবসময় চারটি সাংখ্যিক কম্পোনেন্ট থাকবে যার মান ০ থেকে ২৫৫ এর মধ্যে হবে। যদি আমরা V4 address-কে চারটি u8 মান হিসেবে সংরক্ষণ করতে চাই কিন্তু V6 address-কে একটি String মান হিসাবেই প্রকাশ করতে চাই, তবে আমরা একটি struct দিয়ে তা করতে পারতাম না। enum এই কাজটি সহজেই করতে পারে:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

আমরা ভার্সন ফোর এবং ভার্সন সিক্স IP address সংরক্ষণ করার জন্য ডেটা স্ট্রাকচার ডিফাইন করার বিভিন্ন উপায় দেখিয়েছি। তবে, দেখা যাচ্ছে যে IP address সংরক্ষণ করা এবং সেগুলি কোন প্রকারের তা এনকোড করার প্রয়োজনীয়তা এতটাই সাধারণ যে স্ট্যান্ডার্ড লাইব্রেরিতে আমাদের ব্যবহারের জন্য একটি সংজ্ঞা রয়েছে! আসুন দেখি স্ট্যান্ডার্ড লাইব্রেরি কিভাবে IpAddr ডিফাইন করে: এটিতে আমাদের ডিফাইন করা এবং ব্যবহৃত enum এবং variant-গুলোই আছে, তবে এটি variant-গুলোর ভিতরে address data দুটি ভিন্ন struct-এর আকারে এম্বেড করে, যা প্রতিটি variant-এর জন্য ভিন্নভাবে ডিফাইন করা হয়েছে:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

এই কোডটি দেখায় যে আপনি একটি enum variant-এর ভিতরে যেকোনো ধরনের ডেটা রাখতে পারেন: উদাহরণস্বরূপ, স্ট্রিং, নিউমেরিক টাইপ, বা struct। এমনকি আপনি অন্য একটি enum-ও অন্তর্ভুক্ত করতে পারেন! এছাড়াও, স্ট্যান্ডার্ড লাইব্রেরির type-গুলো প্রায়শই আপনার নিজের ভাবনার চেয়ে খুব বেশি জটিল হয় না।

লক্ষ্য করুন যে যদিও স্ট্যান্ডার্ড লাইব্রেরিতে IpAddr-এর একটি সংজ্ঞা রয়েছে, আমরা এখনও কোনো conflict ছাড়াই আমাদের নিজস্ব সংজ্ঞা তৈরি এবং ব্যবহার করতে পারি কারণ আমরা স্ট্যান্ডার্ড লাইব্রেরির সংজ্ঞাটি আমাদের স্কোপে নিয়ে আসিনি। আমরা চ্যাপ্টার ৭-এ স্কোপে type নিয়ে আসার বিষয়ে আরও আলোচনা করব।

আসুন লিস্টিং ৬-২-এ enum-এর আরেকটি উদাহরণ দেখি: এটিতে এর variant-গুলোর মধ্যে বিভিন্ন ধরণের type এম্বেড করা আছে।

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

এই enum-টির চারটি variant আছে এবং তাদের সাথে বিভিন্ন ধরনের ডেটা যুক্ত আছে:

• Quit: এর সাথে কোনো ডেটা যুক্ত নেই।
• Move: এর মধ্যে struct-এর মতো named field আছে।
• Write: একটি String অন্তর্ভুক্ত করে।
• ChangeColor: তিনটি i32 মান অন্তর্ভুক্ত করে।

লিস্টিং ৬-২-এর মতো variant সহ একটি enum ডিফাইন করা বিভিন্ন ধরণের struct ডিফাইন করার মতোই, তবে enum struct কীওয়ার্ড ব্যবহার করে না এবং সমস্ত variant Message type-এর অধীনে একসাথে গ্রুপ করা হয়। নিম্নলিখিত struct-গুলো পূর্ববর্তী enum variant-গুলোর মতো একই ডেটা ধারণ করতে পারত:

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

কিন্তু যদি আমরা বিভিন্ন struct ব্যবহার করতাম, যার প্রত্যেকটির নিজস্ব type আছে, আমরা তত সহজে একটি function ডিফাইন করতে পারতাম না যা এই ধরনের যেকোনো message নিতে পারে, যেমনটা আমরা লিস্টিং ৬-২-এ ডিফাইন করা Message enum দিয়ে করতে পারি, যা একটি একক type।

enum এবং struct-এর মধ্যে আরও একটি মিল আছে: ঠিক যেমন আমরা impl ব্যবহার করে struct-এর উপর মেথড ডিফাইন করতে পারি, তেমনি আমরা enum-এর উপরও মেথড ডিফাইন করতে পারি। এখানে call নামে একটি মেথড রয়েছে যা আমরা আমাদের Message enum-এ ডিফাইন করতে পারি:

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

মেথডটির বডি self ব্যবহার করে সেই মানটি পাবে যার উপর আমরা মেথডটি কল করেছি। এই উদাহরণে, আমরা একটি ভেরিয়েবল m তৈরি করেছি যার মান Message::Write(String::from("hello")), এবং যখন m.call() চালানো হবে, তখন call মেথডের বডিতে self এটিই হবে।

আসুন স্ট্যান্ডার্ড লাইব্রেরির আরেকটি enum দেখি যা খুব সাধারণ এবং দরকারী: Option।

Option Enum এবং Null ভ্যালুর উপর এর সুবিধা

এই বিভাগটি Option-এর একটি কেস স্টাডি নিয়ে আলোচনা করে, যা স্ট্যান্ডার্ড লাইব্রেরি দ্বারা ডিফাইন করা আরেকটি enum। Option type-টি একটি খুব সাধারণ পরিস্থিতি এনকোড করে যেখানে একটি মান কিছু একটা হতে পারে বা কিছুই নাও হতে পারে।

উদাহরণস্বরূপ, যদি আপনি একটি খালি নয় এমন লিস্ট থেকে প্রথম আইটেমটি অনুরোধ করেন, আপনি একটি মান পাবেন। যদি আপনি একটি খালি লিস্ট থেকে প্রথম আইটেমটি অনুরোধ করেন, আপনি কিছুই পাবেন না। এই ধারণাটিকে type সিস্টেমের ভাষায় প্রকাশ করার অর্থ হলো compiler পরীক্ষা করতে পারে যে আপনি সমস্ত প্রয়োজনীয় কেসগুলি হ্যান্ডেল করেছেন কিনা; এই কার্যকারিতাটি অন্যান্য প্রোগ্রামিং ভাষায় অত্যন্ত সাধারণ বাগ প্রতিরোধ করতে পারে।

প্রোগ্রামিং ভাষার ডিজাইন প্রায়শই কোন বৈশিষ্ট্যগুলি অন্তর্ভুক্ত করা হয় তার উপর ভিত্তি করে ভাবা হয়, তবে কোন বৈশিষ্ট্যগুলি বাদ দেওয়া হয় তাও গুরুত্বপূর্ণ। Rust-এ null বৈশিষ্ট্যটি নেই যা অনেক অন্যান্য ভাষায় রয়েছে। Null হলো এমন একটি মান যার অর্থ সেখানে কোনো মান নেই। যেসব ভাষায় null আছে, সেখানে ভেরিয়েবল সবসময় দুটি অবস্থার একটিতে থাকতে পারে: null অথবা not-null।

তার ২০০৯ সালের উপস্থাপনা "Null References: The Billion Dollar Mistake"-এ, null-এর উদ্ভাবক টনি হোর একথা বলেছিলেন:

আমি এটাকে আমার বিলিয়ন-ডলারের ভুল বলি। সেই সময়ে, আমি একটি অবজেক্ট-ওরিয়েন্টেড ভাষার জন্য রেফারেন্সের প্রথম ব্যাপক টাইপ সিস্টেম ডিজাইন করছিলাম। আমার লক্ষ্য ছিল নিশ্চিত করা যে রেফারেন্সের সমস্ত ব্যবহার একেবারে নিরাপদ হবে, এবং compiler দ্বারা স্বয়ংক্রিয়ভাবে পরীক্ষা করা হবে। কিন্তু আমি একটি null রেফারেন্স রাখার লোভ সামলাতে পারিনি, কারণ এটি বাস্তবায়ন করা খুব সহজ ছিল। এটি অগণিত ভুল, দুর্বলতা এবং সিস্টেম ক্র্যাশের কারণ হয়েছে, যা সম্ভবত গত চল্লিশ বছরে এক বিলিয়ন ডলারের কষ্ট ও ক্ষতির কারণ হয়েছে।

null মানের সমস্যা হলো যে যদি আপনি একটি null মানকে not-null মান হিসাবে ব্যবহার করার চেষ্টা করেন, তবে আপনি কোনো না কোনো ধরনের একটি error পাবেন। যেহেতু এই null বা not-null বৈশিষ্ট্যটি সর্বব্যাপী, তাই এই ধরনের ভুল করা অত্যন্ত সহজ।

তবে, null যে ধারণাটি প্রকাশ করার চেষ্টা করে তা এখনও একটি দরকারী ধারণা: একটি null হলো এমন একটি মান যা বর্তমানে কোনো কারণে অবৈধ বা অনুপস্থিত।

সমস্যাটি আসলে ধারণার সাথে নয়, বরং নির্দিষ্ট বাস্তবায়নের সাথে। তাই, Rust-এ null নেই, তবে এটিতে একটি enum রয়েছে যা একটি মানের উপস্থিতি বা অনুপস্থিতির ধারণাটি এনকোড করতে পারে। এই enum-টি হলো Option<T>, এবং এটি স্ট্যান্ডার্ড লাইব্রেরি দ্বারা ডিফাইন করা হয়েছে এভাবে:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option<T> enum-টি এতটাই দরকারী যে এটি প্রিলিউডেও অন্তর্ভুক্ত করা হয়েছে; আপনাকে এটিকে স্পষ্টভাবে স্কোপে আনতে হবে না। এর variant-গুলোও প্রিলিউডে অন্তর্ভুক্ত: আপনি Option:: উপসর্গ ছাড়াই সরাসরি Some এবং None ব্যবহার করতে পারেন। Option<T> enum-টি এখনও একটি সাধারণ enum, এবং Some(T) ও None এখনও Option<T> type-এর variant।

<T> সিনট্যাক্সটি Rust-এর একটি বৈশিষ্ট্য যা নিয়ে আমরা এখনও কথা বলিনি। এটি একটি জেনেরিক টাইপ প্যারামিটার, এবং আমরা চ্যাপ্টার ১০-এ জেনেরিক সম্পর্কে আরও বিস্তারিত আলোচনা করব। আপাতত, আপনাকে শুধু জানতে হবে যে <T> মানে Option enum-এর Some variant যেকোনো type-এর ডেটার একটি অংশ ধারণ করতে পারে, এবং T-এর পরিবর্তে ব্যবহৃত প্রতিটি সুনির্দিষ্ট type সামগ্রিক Option<T> type-কে একটি ভিন্ন type-এ পরিণত করে। এখানে সংখ্যা এবং ক্যারেক্টার type ধারণ করার জন্য Option মান ব্যবহার করার কিছু উদাহরণ দেওয়া হলো:

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

some_number-এর type হলো Option<i32>। some_char-এর type হলো Option<char>, যা একটি ভিন্ন type। Rust এই type-গুলো অনুমান করতে পারে কারণ আমরা Some variant-এর ভিতরে একটি মান নির্দিষ্ট করেছি। absent_number-এর জন্য, Rust আমাদের সামগ্রিক Option type-টি annotate করতে বলে: compiler শুধুমাত্র একটি None মান দেখে সংশ্লিষ্ট Some variant কোন type ধারণ করবে তা অনুমান করতে পারে না। এখানে, আমরা Rust-কে বলি যে আমরা absent_number-কে Option<i32> type-এর হিসাবে বোঝাতে চাই।

যখন আমাদের কাছে একটি Some মান থাকে, আমরা জানি যে একটি মান উপস্থিত আছে এবং মানটি Some-এর ভিতরে রয়েছে। যখন আমাদের কাছে একটি None মান থাকে, তখন এটি某种 অর্থে null-এর মতোই: আমাদের কাছে একটি বৈধ মান নেই। তাহলে Option<T> থাকাটা null থাকার চেয়ে ভালো কেন?

সংক্ষেপে, কারণ Option<T> এবং T (যেখানে T যেকোনো type হতে পারে) ভিন্ন type, তাই compiler আমাদের একটি Option<T> মানকে এমনভাবে ব্যবহার করতে দেবে না যেন এটি অবশ্যই একটি বৈধ মান। উদাহরণস্বরূপ, এই কোডটি কম্পাইল হবে না, কারণ এটি একটি i8-কে একটি Option<i8>-এর সাথে যোগ করার চেষ্টা করছে:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

যদি আমরা এই কোডটি চালাই, আমরা এই ধরনের একটি error বার্তা পাই:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
  = help: the following other types implement trait `Add<Rhs>`:
            `&i8` implements `Add<i8>`
            `&i8` implements `Add`
            `i8` implements `Add<&i8>`
            `i8` implements `Add`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

ব্যাপক! কার্যতঃ, এই error বার্তাটির অর্থ হলো Rust বুঝতে পারছে না কিভাবে একটি i8 এবং একটি Option<i8> যোগ করতে হয়, কারণ তারা ভিন্ন type। যখন আমাদের কাছে Rust-এ i8-এর মতো কোনো type-এর মান থাকে, তখন compiler নিশ্চিত করবে যে আমাদের কাছে সবসময় একটি বৈধ মান আছে। আমরা সেই মানটি ব্যবহার করার আগে null-এর জন্য পরীক্ষা না করেই আত্মবিশ্বাসের সাথে এগিয়ে যেতে পারি। শুধুমাত্র যখন আমাদের কাছে একটি Option<i8> থাকে (বা আমরা যে ধরনের মান নিয়ে কাজ করছি), তখনই আমাদের একটি মান না থাকার সম্ভাবনা নিয়ে চিন্তা করতে হয়, এবং compiler নিশ্চিত করবে যে আমরা মানটি ব্যবহার করার আগে সেই পরিস্থিতিটি হ্যান্ডেল করি।

অন্য কথায়, T অপারেশন সম্পাদন করার আগে আপনাকে একটি Option<T>-কে T-তে রূপান্তর করতে হবে। সাধারণত, এটি null-এর সবচেয়ে সাধারণ সমস্যাগুলির মধ্যে একটি ধরতে সাহায্য করে: কোনো কিছুকে not-null ধরে নেওয়া যখন এটি আসলে null।

একটি not-null মান ভুলভাবে ধরে নেওয়ার ঝুঁকি দূর করা আপনাকে আপনার কোডের প্রতি আরও আত্মবিশ্বাসী হতে সাহায্য করে। এমন একটি মান পেতে যা সম্ভবত null হতে পারে, আপনাকে স্পষ্টভাবে সেই মানের type-কে Option<T> করে অপ্ট-ইন করতে হবে। তারপরে, যখন আপনি সেই মানটি ব্যবহার করেন, তখন মানটি null হলে সেই কেসটি স্পষ্টভাবে হ্যান্ডেল করতে হবে। যেখানেই একটি মানের type Option<T> নয়, আপনি নিরাপদে ধরে নিতে পারেন যে মানটি null নয়। এটি Rust-এর একটি ইচ্ছাকৃত ডিজাইন সিদ্ধান্ত ছিল null-এর ব্যাপকতা সীমিত করতে এবং Rust কোডের নিরাপত্তা বৃদ্ধি করতে।

তাহলে আপনি কিভাবে Some variant থেকে T মানটি বের করবেন যখন আপনার কাছে Option<T> type-এর একটি মান থাকে, যাতে আপনি সেই মানটি ব্যবহার করতে পারেন? Option<T> enum-এর অনেক মেথড রয়েছে যা বিভিন্ন পরিস্থিতিতে দরকারী; আপনি এর ডকুমেন্টেশনে সেগুলি দেখতে পারেন। Option<T>-এর মেথডগুলোর সাথে পরিচিত হওয়া Rust-এর সাথে আপনার যাত্রায় অত্যন্ত দরকারী হবে।

সাধারণভাবে, একটি Option<T> মান ব্যবহার করার জন্য, আপনার এমন কোড থাকা দরকার যা প্রতিটি variant হ্যান্ডেল করবে। আপনি চান কিছু কোড শুধুমাত্র তখনই চলুক যখন আপনার কাছে একটি Some(T) মান থাকে, এবং এই কোডটি ভিতরের T ব্যবহার করার অনুমতি পায়। আপনি চান অন্য কিছু কোড শুধুমাত্র তখনই চলুক যদি আপনার কাছে একটি None মান থাকে, এবং সেই কোডের কাছে একটি T মান উপলব্ধ থাকে না। match এক্সপ্রেশন একটি কন্ট্রোল ফ্লো কনস্ট্রাক্ট যা enum-এর সাথে ব্যবহার করা হলে ঠিক এই কাজটিই করে: এটি enum-এর কোন variant-টি পেয়েছে তার উপর নির্ভর করে ভিন্ন কোড চালাবে, এবং সেই কোডটি ম্যাচিং মানের ভিতরের ডেটা ব্যবহার করতে পারে।

match কন্ট্রোল ফ্লো কনস্ট্রাক্ট

Rust-এ match নামে একটি অত্যন্ত শক্তিশালী কন্ট্রোল ফ্লো কনস্ট্রাক্ট আছে যা আপনাকে একটি মানকে একাধিক প্যাটার্নের সাথে তুলনা করতে এবং কোন প্যাটার্নটি মেলে তার উপর ভিত্তি করে কোড এক্সিকিউট করতে দেয়। প্যাটার্নগুলো লিটারেল ভ্যালু, ভেরিয়েবলের নাম, ওয়াইল্ডকার্ড এবং আরও অনেক কিছু দিয়ে তৈরি হতে পারে; Chapter 19-এ বিভিন্ন ধরণের প্যাটার্ন এবং তাদের কাজ সম্পর্কে আলোচনা করা হয়েছে। match-এর আসল শক্তি হলো এর প্যাটার্নগুলোর প্রকাশক্ষমতা (expressiveness) এবং compiler এটা নিশ্চিত করে যে সমস্ত সম্ভাব্য কেস হ্যান্ডেল করা হয়েছে।

match এক্সপ্রেশনকে একটি কয়েন বাছাই করার মেশিনের মতো ভাবুন: কয়েনগুলো বিভিন্ন আকারের ছিদ্রযুক্ত একটি ট্র্যাকের উপর দিয়ে স্লাইড করে, এবং প্রতিটি কয়েন প্রথম যে ছিদ্রের সাথে ফিট করে সেটির মধ্যে পড়ে যায়। একইভাবে, match-এর প্রতিটি প্যাটার্নের মধ্য দিয়ে মানগুলো যায়, এবং প্রথম যে প্যাটার্নের সাথে মানটি "ফিট" করে, সেই মানটি সংশ্লিষ্ট কোড ব্লকে পড়ে যায় এবং এক্সিকিউশনের সময় ব্যবহৃত হয়।

কয়েনের কথা যেহেতু উঠলই, চলুন match ব্যবহার করে কয়েনকে উদাহরণ হিসাবে ব্যবহার করি! আমরা এমন একটি ফাংশন লিখতে পারি যা একটি অজানা US কয়েন নেয় এবং কাউন্টিং মেশিনের মতো নির্ধারণ করে যে এটি কোন কয়েন এবং সেন্টে এর মান ফেরত দেয়, যেমনটি লিস্টিং ৬-৩ এ দেখানো হয়েছে।

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

চলুন value_in_cents ফাংশনের match অংশটি ভেঙে দেখি। প্রথমে আমরা match কীওয়ার্ডটি লিখি, যার পরে একটি এক্সপ্রেশন থাকে, এক্ষেত্রে coin ভ্যালুটি। এটি if-এর সাথে ব্যবহৃত কন্ডিশনাল এক্সপ্রেশনের মতোই মনে হতে পারে, কিন্তু একটি বড় পার্থক্য আছে: if-এর ক্ষেত্রে কন্ডিশনটিকে একটি বুলিয়ান (boolean) ভ্যালু হতে হয়, কিন্তু এখানে এটি যেকোনো type-এর হতে পারে। এই উদাহরণে coin-এর type হলো Coin enum, যা আমরা প্রথম লাইনে ডিফাইন করেছি।

এরপর আসে match arm। একটি arm-এর দুটি অংশ থাকে: একটি প্যাটার্ন এবং কিছু কোড। এখানের প্রথম arm-টির প্যাটার্ন হলো Coin::Penny এবং তারপরে => অপারেটর যা প্যাটার্ন এবং চালানোর জন্য কোডকে আলাদা করে। এই ক্ষেত্রে কোডটি শুধু 1 ভ্যালুটি। প্রতিটি arm কমা দ্বারা পরবর্তী arm থেকে পৃথক করা হয়।

যখন match এক্সপ্রেশনটি এক্সিকিউট হয়, এটি তার ফলাফলের মানকে প্রতিটি arm-এর প্যাটার্নের সাথে ক্রমানুসারে তুলনা করে। যদি একটি প্যাটার্ন মানের সাথে মিলে যায়, তবে সেই প্যাটার্নের সাথে যুক্ত কোডটি এক্সিকিউট হয়। যদি সেই প্যাটার্নটি মানের সাথে না মেলে, এক্সিকিউশন পরবর্তী arm-এ চলে যায়, অনেকটা কয়েন বাছাই করার মেশিনের মতো। আমাদের যতগুলো প্রয়োজন ততগুলো arm থাকতে পারে: লিস্টিং ৬-৩-এ, আমাদের match-এর চারটি arm আছে।

প্রতিটি arm-এর সাথে যুক্ত কোড একটি এক্সপ্রেশন, এবং ম্যাচিং arm-এর এক্সপ্রেশনের ফলাফলই পুরো match এক্সপ্রেশনের রিটার্ন ভ্যালু হিসাবে ফেরত আসে।

যখন ম্যাচ arm-এর কোড ছোট হয়, যেমন লিস্টিং ৬-৩-এ যেখানে প্রতিটি arm শুধু একটি ভ্যালু রিটার্ন করে, তখন আমরা সাধারণত কার্লি ব্র্যাকেট ব্যবহার করি না। যদি আপনি একটি ম্যাচ arm-এ একাধিক লাইন কোড চালাতে চান, তবে আপনাকে অবশ্যই কার্লি ব্র্যাকেট ব্যবহার করতে হবে, এবং সেক্ষেত্রে arm-এর পরে কমা দেওয়াটা ঐচ্ছিক। উদাহরণস্বরূপ, নিচের কোডটি যখনই একটি Coin::Penny দিয়ে মেথডটি কল করা হয়, তখন "Lucky penny!" প্রিন্ট করে, কিন্তু ব্লকের শেষ মান, 1, রিটার্ন করে:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

ভ্যালুর সাথে বাইন্ড হওয়া প্যাটার্ন

match arm-এর আরেকটি দরকারী বৈশিষ্ট্য হলো যে তারা প্যাটার্নের সাথে মিলে যাওয়া মানগুলোর অংশে বাইন্ড হতে পারে। এভাবেই আমরা enum ভ্যারিয়েন্ট থেকে মান বের করতে পারি।

উদাহরণস্বরূপ, চলুন আমাদের enum ভ্যারিয়েন্টগুলোর একটিকে পরিবর্তন করে তার ভিতরে ডেটা রাখি। ১৯৯৯ থেকে ২০০৮ সাল পর্যন্ত, মার্কিন যুক্তরাষ্ট্র ৫০টি রাজ্যের জন্য একপাশে বিভিন্ন ডিজাইন সহ কোয়ার্টার তৈরি করেছিল। অন্য কোনো কয়েনে রাজ্যের ডিজাইন ছিল না, তাই শুধুমাত্র কোয়ার্টারেই এই অতিরিক্ত মানটি রয়েছে। আমরা আমাদের enum-এ এই তথ্য যোগ করতে পারি Quarter ভ্যারিয়েন্টটিকে পরিবর্তন করে এর ভিতরে একটি UsState ভ্যালু অন্তর্ভুক্ত করে, যা আমরা লিস্টিং ৬-৪-এ করেছি।

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {}

আসুন কল্পনা করি যে একজন বন্ধু ৫০টি রাজ্যের সমস্ত কোয়ার্টার সংগ্রহ করার চেষ্টা করছে। আমরা যখন আমাদের খুচরা পয়সাগুলো কয়েনের ধরন অনুযায়ী সাজাব, তখন আমরা প্রতিটি কোয়ার্টারের সাথে যুক্ত রাজ্যের নামও ঘোষণা করব যাতে যদি আমাদের বন্ধুর সংগ্রহে সেটি না থাকে, তবে সে তার সংগ্রহে এটি যোগ করতে পারে।

এই কোডের match এক্সপ্রেশনে, আমরা Coin::Quarter ভ্যারিয়েন্টের মানের সাথে মিলে যাওয়া প্যাটার্নে state নামে একটি ভেরিয়েবল যোগ করি। যখন একটি Coin::Quarter মেলে, state ভেরিয়েবলটি সেই কোয়ার্টারের রাজ্যের মানের সাথে বাইন্ড হবে। তারপর আমরা সেই state ভেরিয়েবলটি সেই arm-এর কোডে ব্যবহার করতে পারি, এভাবে:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {state:?}!");
            25
        }
    }
}

fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));
}

যদি আমরা value_in_cents(Coin::Quarter(UsState::Alaska)) কল করি, coin-এর মান হবে Coin::Quarter(UsState::Alaska)। যখন আমরা সেই মানটি প্রতিটি match arm-এর সাথে তুলনা করি, Coin::Quarter(state)-এ না পৌঁছানো পর্যন্ত কোনোটিই মেলে না। সেই সময়ে, state-এর জন্য বাইন্ডিং হবে UsState::Alaska মানটি। আমরা তখন সেই বাইন্ডিংটি println! এক্সপ্রেশনে ব্যবহার করতে পারি, যার ফলে Coin enum-এর Quarter ভ্যারিয়েন্ট থেকে ভিতরের রাজ্যের মানটি বের করে আনা যায়।

Option<T> এর সাথে ম্যাচিং

আগের বিভাগে, আমরা Option<T> ব্যবহার করার সময় Some কেস থেকে ভিতরের T মানটি বের করতে চেয়েছিলাম; আমরা Option<T>-কেও match ব্যবহার করে হ্যান্ডেল করতে পারি, যেমনটি আমরা Coin enum-এর সাথে করেছিলাম! কয়েন তুলনা করার পরিবর্তে, আমরা Option<T>-এর ভ্যারিয়েন্টগুলো তুলনা করব, কিন্তু match এক্সপ্রেশনের কাজ করার পদ্ধতি একই থাকে।

ধরুন আমরা একটি ফাংশন লিখতে চাই যা একটি Option<i32> নেয় এবং যদি ভিতরে একটি মান থাকে, তবে সেই মানের সাথে ১ যোগ করে। যদি ভিতরে কোনো মান না থাকে, ফাংশনটি None মান ফেরত দেবে এবং কোনো অপারেশন করার চেষ্টা করবে না।

match-এর সৌজন্যে এই ফাংশনটি লেখা খুব সহজ, এবং এটি লিস্টিং ৬-৫-এর মতো দেখাবে।

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

আসুন plus_one-এর প্রথম এক্সিকিউশনটি আরও বিস্তারিতভাবে পরীক্ষা করি। যখন আমরা plus_one(five) কল করি, plus_one-এর বডিতে x ভেরিয়েবলের মান হবে Some(5)। তারপর আমরা সেটিকে প্রতিটি match arm-এর সাথে তুলনা করি:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Some(5) মানটি None প্যাটার্নের সাথে মেলে না, তাই আমরা পরবর্তী arm-এ যাই:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Some(5) কি Some(i)-এর সাথে মেলে? হ্যাঁ, মেলে! আমাদের একই ভ্যারিয়েন্ট আছে। i ভেরিয়েবলটি Some-এর ভিতরের মানের সাথে বাইন্ড হয়, তাই i-এর মান 5 হয়। ম্যাচ arm-এর কোডটি তখন এক্সিকিউট হয়, তাই আমরা i-এর মানের সাথে ১ যোগ করি এবং আমাদের মোট 6-কে ভিতরে নিয়ে একটি নতুন Some মান তৈরি করি।

এবার লিস্টিং ৬-৫-এ plus_one-এর দ্বিতীয় কলটি বিবেচনা করা যাক, যেখানে x হলো None। আমরা match-এ প্রবেশ করি এবং প্রথম arm-এর সাথে তুলনা করি:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

এটা মিলে গেছে! যোগ করার জন্য কোনো মান নেই, তাই প্রোগ্রামটি থেমে যায় এবং =>-এর ডান পাশের None মানটি রিটার্ন করে। যেহেতু প্রথম arm-টি মিলে গেছে, অন্য কোনো arm-এর সাথে আর তুলনা করা হয় না।

match এবং enum একত্রিত করা অনেক পরিস্থিতিতে দরকারী। আপনি Rust কোডে এই প্যাটার্নটি প্রায়শই দেখবেন: একটি enum-এর উপর match করা, ভিতরের ডেটার সাথে একটি ভেরিয়েবল বাইন্ড করা, এবং তারপর তার উপর ভিত্তি করে কোড চালানো। প্রথমে এটি কিছুটা জটিল মনে হতে পারে, কিন্তু একবার আপনি এতে অভ্যস্ত হয়ে গেলে, আপনার মনে হবে যদি সব ভাষাতেই এটি থাকত। এটি ব্যবহারকারীদের মধ্যে ধারাবাহিকভাবে একটি প্রিয় ফিচার।

ম্যাচগুলো সম্পূর্ণ (Exhaustive) হতে হয়

match-এর আরও একটি দিক নিয়ে আমাদের আলোচনা করতে হবে: arm-এর প্যাটার্নগুলোকে অবশ্যই সমস্ত সম্ভাবনাকে কভার করতে হবে। আমাদের plus_one ফাংশনের এই সংস্করণটি বিবেচনা করুন, যাতে একটি বাগ আছে এবং এটি কম্পাইল হবে না:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

আমরা None কেসটি হ্যান্ডেল করিনি, তাই এই কোডটি একটি বাগ তৈরি করবে। সৌভাগ্যবশত, এটি এমন একটি বাগ যা Rust ধরতে জানে। যদি আমরা এই কোডটি কম্পাইল করার চেষ্টা করি, আমরা এই error পাব:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:3:15
  |
3 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/option.rs:572:1
 ::: /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/option.rs:576:5
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust জানে যে আমরা প্রতিটি সম্ভাব্য কেস কভার করিনি, এবং এমনকি কোন প্যাটার্নটি আমরা ভুলে গেছি সেটাও জানে! Rust-এর ম্যাচগুলো exhaustive বা সম্পূর্ণ: কোডটি বৈধ হওয়ার জন্য আমাদের অবশ্যই প্রতিটি সম্ভাবনাকে শেষ করতে হবে। বিশেষ করে Option<T>-এর ক্ষেত্রে, যখন Rust আমাদের None কেসটি স্পষ্টভাবে হ্যান্ডেল করতে ভুলে যাওয়া থেকে বিরত রাখে, তখন এটি আমাদের এমন একটি মান আছে বলে ধরে নেওয়া থেকে রক্ষা করে যখন আমাদের কাছে null থাকতে পারে, যার ফলে আগে আলোচিত বিলিয়ন-ডলারের ভুলটি অসম্ভব হয়ে যায়।

ক্যাচ-অল প্যাটার্ন এবং _ প্লেসহোল্ডার

enum ব্যবহার করে, আমরা কয়েকটি নির্দিষ্ট মানের জন্য বিশেষ পদক্ষেপ নিতে পারি, কিন্তু অন্য সব মানের জন্য একটি ডিফল্ট পদক্ষেপ নিতে পারি। কল্পনা করুন আমরা একটি গেম তৈরি করছি যেখানে, যদি আপনি একটি ডাইস রোলে ৩ পান, আপনার প্লেয়ার নড়াচড়া করে না, বরং একটি নতুন সুন্দর টুপি পায়। যদি আপনি ৭ পান, আপনার প্লেয়ার একটি সুন্দর টুপি হারায়। অন্য সব মানের জন্য, আপনার প্লেয়ার গেম বোর্ডে সেই সংখ্যক ঘর সরে যায়। এখানে একটি match রয়েছে যা সেই যুক্তিটি বাস্তবায়ন করে, যেখানে ডাইস রোলের ফলাফল একটি র্যান্ডম মানের পরিবর্তে হার্ডকোড করা হয়েছে, এবং অন্য সমস্ত যুক্তি বডি ছাড়া ফাংশন দ্বারা প্রতিনিধিত্ব করা হয়েছে কারণ সেগুলির বাস্তবায়ন এই উদাহরণের আওতার বাইরে:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        other => move_player(other),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn move_player(num_spaces: u8) {}
}

প্রথম দুটি arm-এর জন্য, প্যাটার্নগুলি হলো লিটারেল মান 3 এবং 7। শেষ arm-টির জন্য যা অন্য সব সম্ভাব্য মানকে কভার করে, প্যাটার্নটি হলো other নামে একটি ভেরিয়েবল। other arm-এর জন্য যে কোডটি চলে তা move_player ফাংশনে ভেরিয়েবলটি পাস করে ব্যবহার করে।

এই কোডটি কম্পাইল হয়, যদিও আমরা u8-এর সমস্ত সম্ভাব্য মান তালিকাভুক্ত করিনি, কারণ শেষ প্যাটার্নটি বিশেষভাবে তালিকাভুক্ত নয় এমন সমস্ত মানকে ম্যাচ করবে। এই ক্যাচ-অল প্যাটার্নটি match-এর সম্পূর্ণ (exhaustive) হওয়ার প্রয়োজনীয়তা পূরণ করে। মনে রাখবেন যে আমাদের ক্যাচ-অল arm-টি শেষে রাখতে হবে কারণ প্যাটার্নগুলো ক্রমানুসারে মূল্যায়ন করা হয়। যদি আমরা ক্যাচ-অল arm-টি আগে রাখি, অন্য arm-গুলো কখনওই চলবে না, তাই Rust আমাদের সতর্ক করবে যদি আমরা একটি ক্যাচ-অল-এর পরে arm যোগ করি!

Rust-এর আরও একটি প্যাটার্ন আছে যা আমরা ব্যবহার করতে পারি যখন আমরা একটি ক্যাচ-অল চাই কিন্তু ক্যাচ-অল প্যাটার্নের মানটি ব্যবহার করতে চাই না: _ একটি বিশেষ প্যাটার্ন যা যেকোনো মানকে ম্যাচ করে এবং সেই মানের সাথে বাইন্ড হয় না। এটি Rust-কে বলে যে আমরা মানটি ব্যবহার করতে যাচ্ছি না, তাই Rust আমাদের একটি অব্যবহৃত ভেরিয়েবল সম্পর্কে সতর্ক করবে না।

আসুন গেমের নিয়ম পরিবর্তন করি: এখন, যদি আপনি ৩ বা ৭ ছাড়া অন্য কিছু রোল করেন, আপনাকে আবার রোল করতে হবে। আমাদের আর ক্যাচ-অল মানটি ব্যবহার করার প্রয়োজন নেই, তাই আমরা আমাদের কোডটি পরিবর্তন করে other ভেরিয়েবলের পরিবর্তে _ ব্যবহার করতে পারি:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => reroll(),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn reroll() {}
}

এই উদাহরণটিও সম্পূর্ণতার (exhaustiveness) প্রয়োজনীয়তা পূরণ করে কারণ আমরা শেষ arm-এ অন্য সব মানকে স্পষ্টভাবে উপেক্ষা করছি; আমরা কিছুই ভুলে যাইনি।

অবশেষে, আমরা গেমের নিয়ম আরও একবার পরিবর্তন করব যাতে আপনি যদি ৩ বা ৭ ছাড়া অন্য কিছু রোল করেন তবে আপনার টার্নে আর কিছুই হবে না। আমরা _ arm-এর সাথে যুক্ত কোড হিসাবে ইউনিট ভ্যালু (খালি টাপল টাইপ যা আমরা "The Tuple Type" বিভাগে উল্লেখ করেছি) ব্যবহার করে এটি প্রকাশ করতে পারি:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
}

এখানে, আমরা Rust-কে স্পষ্টভাবে বলছি যে আমরা আগের arm-গুলোর কোনো প্যাটার্নের সাথে মেলে না এমন অন্য কোনো মান ব্যবহার করতে যাচ্ছি না, এবং আমরা এই ক্ষেত্রে কোনো কোড চালাতে চাই না।

প্যাটার্ন এবং ম্যাচিং সম্পর্কে আরও অনেক কিছু আছে যা আমরা Chapter 19-এ আলোচনা করব। আপাতত, আমরা if let সিনট্যাক্সে চলে যাচ্ছি, যা এমন পরিস্থিতিতে কার্যকর হতে পারে যেখানে match এক্সপ্রেশনটি কিছুটা শব্দবহুল হয়।

if let এবং let else দিয়ে সংক্ষিপ্ত কন্ট্রোল ফ্লো

if let সিনট্যাক্সটি আপনাকে if এবং let-কে একত্রিত করে একটি কম শব্দবহুল উপায়ে এমন ভ্যালুগুলো হ্যান্ডেল করতে দেয় যা একটি প্যাটার্নের সাথে মেলে, এবং বাকিগুলোকে উপেক্ষা করে। লিস্টিং ৬-৬ এর প্রোগ্রামটি বিবেচনা করুন যা config_max ভেরিয়েবলের একটি Option<u8> মানের উপর ম্যাচ করে কিন্তু শুধুমাত্র তখনই কোড চালাতে চায় যখন মানটি Some ভ্যারিয়েন্ট হয়।

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is configured to be {max}"),
        _ => (),
    }
}

যদি মানটি Some হয়, আমরা প্যাটার্নে max ভেরিয়েবলের সাথে মানটি বাইন্ড করে Some ভ্যারিয়েন্টের ভিতরের মানটি প্রিন্ট করি। আমরা None ভ্যালু নিয়ে কিছু করতে চাই না। match এক্সপ্রেশনকে সন্তুষ্ট করার জন্য, আমাদের শুধুমাত্র একটি ভ্যারিয়েন্ট প্রসেস করার পরে _ => () যোগ করতে হয়, যা একটি বিরক্তিকর বাড়তি কোড।

এর পরিবর্তে, আমরা if let ব্যবহার করে এটি আরও সংক্ষিপ্তভাবে লিখতে পারি। নিচের কোডটি লিস্টিং ৬-৬ এর match-এর মতোই আচরণ করে:

fn main() {
    let config_max = Some(3u8);
    if let Some(max) = config_max {
        println!("The maximum is configured to be {max}");
    }
}```

`if let` সিনট্যাক্সটি একটি প্যাটার্ন এবং একটি এক্সপ্রেশন নেয় যা একটি সমান চিহ্ন দ্বারা পৃথক করা থাকে। এটি `match`-এর মতোই কাজ করে, যেখানে এক্সপ্রেশনটি `match`-কে দেওয়া হয় এবং প্যাটার্নটি তার প্রথম arm হয়। এই ক্ষেত্রে, প্যাটার্নটি হলো `Some(max)`, এবং `max` ভেরিয়েবলটি `Some`-এর ভিতরের মানের সাথে বাইন্ড হয়। আমরা তখন `if let` ব্লকের বডিতে `max` ব্যবহার করতে পারি, ঠিক যেমন আমরা সংশ্লিষ্ট `match` arm-এ `max` ব্যবহার করেছিলাম। `if let` ব্লকের কোডটি কেবল তখনই চলে যদি মানটি প্যাটার্নের সাথে মেলে।

`if let` ব্যবহার করার অর্থ হলো কম টাইপিং, কম ইনডেন্টেশন এবং কম বাড়তি কোড। তবে, আপনি `match`-এর সেই সম্পূর্ণ চেকিং (exhaustive checking) হারান যা নিশ্চিত করে যে আপনি কোনো কেস হ্যান্ডেল করতে ভুলে যাচ্ছেন না। `match` এবং `if let`-এর মধ্যে কোনটি বেছে নেবেন তা নির্ভর করে আপনার নির্দিষ্ট পরিস্থিতিতে আপনি কী করছেন এবং সংক্ষিপ্ততা পাওয়ার জন্য সম্পূর্ণ চেকিং হারানোর ট্রেড-অফটি উপযুক্ত কিনা তার উপর।

অন্য কথায়, আপনি `if let`-কে একটি `match`-এর জন্য সিনট্যাক্স সুগার (syntax sugar) হিসাবে ভাবতে পারেন যা মান একটি প্যাটার্নের সাথে মিললে কোড চালায় এবং তারপর অন্য সব মানকে উপেক্ষা করে।

আমরা `if let`-এর সাথে একটি `else` অন্তর্ভুক্ত করতে পারি। `else`-এর সাথে থাকা কোড ব্লকটি সেই কোড ব্লকের মতোই যা `_` কেসের সাথে যেত, যা `if let` এবং `else`-এর সমতুল্য `match` এক্সপ্রেশনে থাকতো। লিস্টিং ৬-৪-এর `Coin` enum সংজ্ঞাটি মনে করুন, যেখানে `Quarter` ভ্যারিয়েন্টটিতে একটি `UsState` মানও ছিল। যদি আমরা কোয়ার্টারগুলোর রাজ্যের নাম ঘোষণা করার পাশাপাশি দেখা সমস্ত নন-কোয়ার্টার কয়েন গণনা করতে চাই, আমরা এটি একটি `match` এক্সপ্রেশন দিয়ে করতে পারতাম, এভাবে:

```rust
#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    match coin {
        Coin::Quarter(state) => println!("State quarter from {state:?}!"),
        _ => count += 1,
    }
}

অথবা আমরা একটি if let এবং else এক্সপ্রেশন ব্যবহার করতে পারতাম, এভাবে:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("State quarter from {state:?}!");
    } else {
        count += 1;
    }
}

let...else ব্যবহার করে “হ্যাপি পাথে” থাকা

একটি সাধারণ প্যাটার্ন হলো যখন একটি মান উপস্থিত থাকে তখন কিছু গণনা করা এবং অন্যথায় একটি ডিফল্ট মান ফেরত দেওয়া। আমাদের UsState মানসহ কয়েনের উদাহরণটি চালিয়ে গেলে, যদি আমরা কোয়ার্টারের উপর থাকা রাজ্যের বয়সের উপর নির্ভর করে মজার কিছু বলতে চাই, আমরা একটি রাজ্যের বয়স পরীক্ষা করার জন্য UsState-এ একটি মেথড যুক্ত করতে পারি, এভাবে:

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

তারপর আমরা কয়েনের ধরনের উপর ম্যাচ করার জন্য if let ব্যবহার করতে পারি, কন্ডিশনের বডির মধ্যে একটি state ভেরিয়েবল চালু করে, যেমনটি লিস্টিং ৬-৭-এ দেখানো হয়েছে।

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

এটি কাজটি সম্পন্ন করে, কিন্তু এটি কাজটি if let স্টেটমেন্টের বডির মধ্যে ঠেলে দিয়েছে, এবং যদি কাজটি আরও জটিল হয়, তবে টপ-লেভেল ব্রাঞ্চগুলো কীভাবে সম্পর্কিত তা বোঝা কঠিন হতে পারে। আমরা if let থেকে state তৈরি করতে বা আগেভাগেই রিটার্ন করতে এক্সপ্রেশনগুলো একটি মান তৈরি করে এই সত্যের সুবিধাও নিতে পারি, যেমনটি লিস্টিং ৬-৮-এ দেখানো হয়েছে। (আপনি match দিয়েও একই রকম করতে পারেন।)

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let state = if let Coin::Quarter(state) = coin {
        state
    } else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

তবে এটিও তার নিজস্ব উপায়ে অনুসরণ করা কিছুটা বিরক্তিকর! if let-এর একটি ব্রাঞ্চ একটি মান তৈরি করে, এবং অন্যটি ফাংশন থেকে পুরোপুরি রিটার্ন করে।

এই সাধারণ প্যাটার্নটিকে আরও সুন্দরভাবে প্রকাশ করার জন্য, Rust-এ let...else রয়েছে। let...else সিনট্যাক্সটি বাম দিকে একটি প্যাটার্ন এবং ডানদিকে একটি এক্সপ্রেশন নেয়, যা if let-এর মতোই, তবে এটির কোনো if ব্রাঞ্চ নেই, কেবল একটি else ব্রাঞ্চ আছে। যদি প্যাটার্নটি মেলে, এটি বাইরের স্কোপে প্যাটার্ন থেকে মানটি বাইন্ড করবে। যদি প্যাটার্নটি না মেলে, প্রোগ্রামটি else arm-এ চলে যাবে, যা অবশ্যই ফাংশন থেকে রিটার্ন করতে হবে।

লিস্টিং ৬-৯-এ, আপনি দেখতে পারেন লিস্টিং ৬-৮ if let-এর পরিবর্তে let...else ব্যবহার করলে কেমন দেখায়।

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

লক্ষ্য করুন যে এটি ফাংশনের প্রধান বডিতে "হ্যাপি পাথে" (on the happy path) থাকে, if let-এর মতো দুটি ব্রাঞ্চের জন্য উল্লেখযোগ্যভাবে ভিন্ন কন্ট্রোল ফ্লো ছাড়াই।

যদি আপনার এমন পরিস্থিতি থাকে যেখানে আপনার প্রোগ্রামের যুক্তি একটি match ব্যবহার করে প্রকাশ করার জন্য খুব শব্দবহুল হয়, মনে রাখবেন যে if let এবং let...else আপনার Rust টুলবক্সেও রয়েছে।

সারাংশ

আমরা এখন কাস্টম type তৈরি করতে enum কীভাবে ব্যবহার করতে হয় তা কভার করেছি যা একটি গণনাকৃত মানের সেটের মধ্যে একটি হতে পারে। আমরা দেখিয়েছি কীভাবে স্ট্যান্ডার্ড লাইব্রেরির Option<T> type আপনাকে type সিস্টেম ব্যবহার করে error প্রতিরোধ করতে সহায়তা করে। যখন enum মানগুলোর ভিতরে ডেটা থাকে, আপনি match বা if let ব্যবহার করে সেই মানগুলো এক্সট্র্যাক্ট এবং ব্যবহার করতে পারেন, এটি নির্ভর করে আপনার কতগুলো কেস হ্যান্ডেল করতে হবে তার উপর।

আপনার Rust প্রোগ্রামগুলো এখন আপনার ডোমেনের ধারণাগুলো structs এবং enums ব্যবহার করে প্রকাশ করতে পারে। আপনার API-তে ব্যবহারের জন্য কাস্টম type তৈরি করা type safety নিশ্চিত করে: compiler নিশ্চিত করবে যে আপনার ফাংশনগুলো কেবল সেই type-এর মান পায় যা প্রতিটি ফাংশন আশা করে।

আপনার ব্যবহারকারীদের জন্য একটি সুসংগঠিত API সরবরাহ করার জন্য যা ব্যবহার করা সহজ এবং শুধুমাত্র ব্যবহারকারীদের যা প্রয়োজন তা প্রকাশ করে, আসুন এখন Rust-এর মডিউলগুলোর দিকে নজর দেওয়া যাক।

প্যাকেজ, ক্রেট এবং মডিউলের মাধ্যমে ক্রমবর্ধমান প্রজেক্ট ম্যানেজ করা

আপনি যখন বড় প্রোগ্রাম লিখবেন, আপনার কোড অর্গানাইজ করা ক্রমশ গুরুত্বপূর্ণ হয়ে উঠবে। সম্পর্কিত ফাংশনালিটি গ্রুপ করে এবং ভিন্ন ভিন্ন ফিচারসহ কোডকে আলাদা করে, আপনি স্পষ্ট করতে পারবেন যে একটি নির্দিষ্ট ফিচার ইমপ্লিমেন্ট করা কোড কোথায় খুঁজে পাওয়া যাবে এবং সেই ফিচারের কার্যকারিতা পরিবর্তন করতে কোথায় যেতে হবে।

এখন পর্যন্ত আমরা যে প্রোগ্রামগুলো লিখেছি তা একটি ফাইলের একটি মডিউলের মধ্যে ছিল। একটি প্রজেক্ট যখন বড় হয়, তখন কোডকে একাধিক মডিউল এবং তারপর একাধিক ফাইলে বিভক্ত করে অর্গানাইজ করা উচিত। একটি প্যাকেজে একাধিক বাইনারি ক্রেট এবং ঐচ্ছিকভাবে একটি লাইব্রেরি ক্রেট থাকতে পারে। প্যাকেজ বড় হওয়ার সাথে সাথে, আপনি এর কিছু অংশ আলাদা ক্রেটে এক্সট্র্যাক্ট করতে পারেন যা এক্সটার্নাল ডিপেন্ডেন্সি হয়ে ওঠে। এই অধ্যায়ে এই সমস্ত কৌশল নিয়ে আলোচনা করা হয়েছে। খুব বড় প্রজেক্টের জন্য, যেখানে একগুচ্ছ আন্তঃসম্পর্কিত প্যাকেজ একসাথে বিকশিত হয়, কার্গো (Cargo) workspaces সরবরাহ করে, যা আমরা অধ্যায় ১৪-এর “কার্গো ওয়ার্কস্পেস” বিভাগে আলোচনা করব।

আমরা ইমপ্লিমেন্টেশন ডিটেইলস এনক্যাপসুলেট করা নিয়েও আলোচনা করব, যা আপনাকে উচ্চ স্তরে কোড পুনঃব্যবহার (reuse) করতে দেয়: একবার আপনি একটি অপারেশন ইমপ্লিমেন্ট করার পর, অন্য কোড আপনার কোডের পাবলিক ইন্টারফেসের মাধ্যমে তাকে কল করতে পারে, এর ইমপ্লিমেন্টেশন কীভাবে কাজ করে তা না জেনেই। আপনি যেভাবে কোড লিখেন তা নির্ধারণ করে কোন অংশগুলো অন্য কোডের ব্যবহারের জন্য পাবলিক থাকবে এবং কোন অংশগুলো প্রাইভেট ইমপ্লিমেন্টেশন ডিটেইলস যা আপনি পরিবর্তন করার অধিকার রাখেন। এটি আপনার মাথায় রাখার মতো বিবরণের পরিমাণ সীমিত করার আরেকটি উপায়।

এর সাথে সম্পর্কিত একটি ধারণা হলো স্কোপ (scope): যে নেস্টেড কনটেক্সটে কোড লেখা হয়, সেখানে একটি নামের সেট থাকে যা “ইন স্কোপ” (in scope) হিসেবে সংজ্ঞায়িত। কোড পড়া, লেখা এবং কম্পাইল করার সময়, প্রোগ্রামার এবং কম্পাইলারদের জানতে হবে যে একটি নির্দিষ্ট স্থানের একটি নির্দিষ্ট নাম কোনো variable, function, struct, enum, module, constant বা অন্য কোনো আইটেমকে নির্দেশ করে কিনা এবং সেই আইটেমটির অর্থ কী। আপনি স্কোপ তৈরি করতে পারেন এবং কোন নামগুলো স্কোপের ভিতরে বা বাইরে থাকবে তা পরিবর্তন করতে পারেন। আপনি একই স্কোপে একই নামের দুটি আইটেম রাখতে পারবেন না; নাম সংক্রান্ত বিরোধ (name conflicts) মেটানোর জন্য টুলস উপলব্ধ আছে।

রাস্টের বেশ কিছু ফিচার আছে যা আপনাকে আপনার কোডের অর্গানাইজেশন পরিচালনা করতে সাহায্য করে, যার মধ্যে রয়েছে কোন ডিটেইলস এক্সপোজ করা হবে, কোন ডিটেইলস প্রাইভেট থাকবে, এবং আপনার প্রোগ্রামের প্রতিটি স্কোপে কোন নামগুলো থাকবে। এই ফিচারগুলোকে কখনও কখনও সম্মিলিতভাবে মডিউল সিস্টেম (module system) বলা হয়, যার মধ্যে রয়েছে:

• প্যাকেজ (Packages): কার্গোর একটি ফিচার যা আপনাকে ক্রেট বিল্ড, টেস্ট এবং শেয়ার করতে দেয়।
• ক্রেট (Crates): মডিউলের একটি ট্রি যা একটি লাইব্রেরি বা এক্সিকিউটেবল তৈরি করে।
• মডিউল এবং use: আপনাকে পাথের অর্গানাইজেশন, স্কোপ এবং প্রাইভেসি নিয়ন্ত্রণ করতে দেয়।
• পাথ (Paths): একটি আইটেম, যেমন কোনো struct, function, বা module-এর নামকরণ করার একটি উপায়।

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

প্যাকেজ এবং ক্রেট

মডিউল সিস্টেমের প্রথম যে অংশগুলো নিয়ে আমরা আলোচনা করব তা হলো প্যাকেজ এবং ক্রেট।

একটি ক্রেট (crate) হলো কোডের সবচেয়ে ছোট অংশ যা রাস্ট কম্পাইলার একবারে বিবেচনা করে। এমনকি যদি আপনি cargo-র পরিবর্তে rustc রান করেন এবং একটি মাত্র সোর্স কোড ফাইল পাস করেন (যেমনটা আমরা প্রথম অধ্যায়ের “একটি রাস্ট প্রোগ্রাম লেখা এবং রান করা” অংশে করেছিলাম), কম্পাইলার সেই ফাইলটিকে একটি ক্রেট হিসেবে বিবেচনা করে। ক্রেট-এর মধ্যে মডিউল থাকতে পারে, এবং সেই মডিউলগুলো অন্য ফাইলে ডিফাইন করা থাকতে পারে যা ক্রেটের সাথে কম্পাইল হয়, যা আমরা পরবর্তী বিভাগগুলিতে দেখব।

একটি ক্রেট দুই ধরনের হতে পারে: একটি বাইনারি ক্রেট অথবা একটি লাইব্রেরি ক্রেট। বাইনারি ক্রেট (Binary crates) হলো এমন প্রোগ্রাম যা আপনি একটি এক্সিকিউটেবল (executable) হিসেবে কম্পাইল করতে পারেন, যেমন একটি কমান্ড লাইন প্রোগ্রাম বা একটি সার্ভার। প্রতিটিতে অবশ্যই main নামের একটি ফাংশন থাকতে হবে যা এক্সিকিউটেবল রান হলে কী ঘটবে তা নির্ধারণ করে। আমরা এখন পর্যন্ত যতগুলো ক্রেট তৈরি করেছি তার সবই বাইনারি ক্রেট।

লাইব্রেরি ক্রেট (Library crates)-এর কোনো main ফাংশন নেই এবং এগুলো এক্সিকিউটেবল হিসেবে কম্পাইল হয় না। এর পরিবর্তে, তারা এমন ফাংশনালিটি ডিফাইন করে যা একাধিক প্রজেক্টের সাথে শেয়ার করার জন্য তৈরি। উদাহরণস্বরূপ, আমরা দ্বিতীয় অধ্যায়ে যে rand ক্রেট ব্যবহার করেছি, তা র‍্যান্ডম নম্বর জেনারেট করার ফাংশনালিটি প্রদান করে। বেশিরভাগ সময় যখন Rustacean-রা “ক্রেট” বলেন, তখন তারা লাইব্রেরি ক্রেটকেই বোঝান, এবং তারা “ক্রেট” শব্দটিকে সাধারণ প্রোগ্রামিং ধারণা “লাইব্রেরি”-র সমার্থক হিসেবে ব্যবহার করেন।

ক্রেট রুট (crate root) হলো একটি সোর্স ফাইল যেখান থেকে রাস্ট কম্পাইলার কাজ শুরু করে এবং যা আপনার ক্রেটের রুট মডিউল তৈরি করে (আমরা মডিউল সম্পর্কে বিস্তারিতভাবে “স্কোপ এবং প্রাইভেসি নিয়ন্ত্রণের জন্য মডিউল ডিফাইন করা” বিভাগে ব্যাখ্যা করব)।

একটি প্যাকেজ (package) হলো এক বা একাধিক ক্রেটের একটি বান্ডিল যা একটি নির্দিষ্ট সেট অফ ফাংশনালিটি প্রদান করে। একটি প্যাকেজে একটি Cargo.toml ফাইল থাকে যা বর্ণনা করে কিভাবে সেই ক্রেটগুলো বিল্ড করতে হবে। কার্গো (Cargo) নিজেও আসলে একটি প্যাকেজ যা আপনার কোড বিল্ড করার জন্য ব্যবহৃত কমান্ড লাইন টুলের বাইনারি ক্রেট ধারণ করে। কার্গো প্যাকেজে একটি লাইব্রেরি ক্রেটও রয়েছে যার উপর বাইনারি ক্রেটটি নির্ভর করে। অন্যান্য প্রজেক্টগুলো কার্গো কমান্ড লাইন টুলের মতো একই লজিক ব্যবহার করার জন্য কার্গো লাইব্রেরি ক্রেটের উপর নির্ভর করতে পারে।

একটি প্যাকেজে আপনার ইচ্ছামত যত খুশি বাইনারি ক্রেট থাকতে পারে, কিন্তু সর্বোচ্চ একটি লাইব্রেরি ক্রেট থাকতে পারে। একটি প্যাকেজে অবশ্যই কমপক্ষে একটি ক্রেট থাকতে হবে, তা লাইব্রেরি হোক বা বাইনারি।

চলুন দেখি একটি প্যাকেজ তৈরি করলে কী ঘটে। প্রথমে আমরা cargo new my-project কমান্ডটি প্রবেশ করাই:

$ cargo new my-project
     Created binary (application) `my-project` package
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs

cargo new my-project চালানোর পর, কার্গো কী তৈরি করেছে তা দেখার জন্য আমরা ls ব্যবহার করি। প্রজেক্ট ডিরেক্টরিতে, একটি Cargo.toml ফাইল রয়েছে, যা আমাদের একটি প্যাকেজ দেয়। এছাড়াও একটি src ডিরেক্টরি রয়েছে যার মধ্যে main.rs ফাইলটি আছে। আপনার টেক্সট এডিটরে Cargo.toml খুলুন, এবং লক্ষ্য করুন যে সেখানে src/main.rs সম্পর্কে কোনো উল্লেখ নেই। কার্গো এই কনভেনশন অনুসরণ করে যে, src/main.rs হলো প্যাকেজের নামের সাথে মিলিয়ে একটি বাইনারি ক্রেটের ক্রেট রুট। একইভাবে, কার্গো জানে যে যদি প্যাকেজ ডিরেক্টরিতে src/lib.rs থাকে, তাহলে প্যাকেজটিতে প্যাকেজের নামের সাথে মিলিয়ে একটি লাইব্রেরি ক্রেট রয়েছে, এবং src/lib.rs হলো তার ক্রেট রুট। কার্গো লাইব্রেরি বা বাইনারি বিল্ড করার জন্য ক্রেট রুট ফাইলগুলো rustc-কে পাস করে।

এখানে, আমাদের একটি প্যাকেজ আছে যাতে শুধুমাত্র src/main.rs রয়েছে, যার অর্থ হলো এটিতে শুধুমাত্র my-project নামের একটি বাইনারি ক্রেট আছে। যদি একটি প্যাকেজে src/main.rs এবং src/lib.rs উভয়ই থাকে, তবে এটির দুটি ক্রেট রয়েছে: একটি বাইনারি এবং একটি লাইব্রেরি, এবং উভয়ের নামই প্যাকেজের নামের সমান হয়। একটি প্যাকেজে একাধিক বাইনারি ক্রেট থাকতে পারে src/bin ডিরেক্টরিতে ফাইল রাখার মাধ্যমে: প্রতিটি ফাইল একটি পৃথক বাইনারি ক্রেট হবে।

স্কোপ এবং প্রাইভেসি নিয়ন্ত্রণের জন্য মডিউল ডিফাইন করা

এই বিভাগে, আমরা মডিউল এবং মডিউল সিস্টেমের অন্যান্য অংশ নিয়ে কথা বলব, যেমন পাথ (paths), যা আপনাকে বিভিন্ন আইটেমের নামকরণ করতে দেয়; use কীওয়ার্ড, যা একটি পাথকে স্কোপের মধ্যে নিয়ে আসে; এবং pub কীওয়ার্ড, যা আইটেমগুলোকে পাবলিক করে। আমরা as কীওয়ার্ড, এক্সটার্নাল প্যাকেজ এবং গ্লোব অপারেটর নিয়েও আলোচনা করব।

মডিউল চিট শিট

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

• ক্রেট রুট থেকে শুরু করুন: একটি ক্রেট কম্পাইল করার সময়, কম্পাইলার প্রথমে ক্রেট রুট ফাইলে (সাধারণত একটি লাইব্রেরি ক্রেটের জন্য src/lib.rs বা একটি বাইনারি ক্রেটের জন্য src/main.rs) কম্পাইল করার জন্য কোড খোঁজে।
• মডিউল ডিক্লেয়ার করা: ক্রেট রুট ফাইলে, আপনি নতুন মডিউল ডিক্লেয়ার করতে পারেন; ধরুন আপনি mod garden; দিয়ে একটি “garden” মডিউল ডিক্লেয়ার করলেন। কম্পাইলার মডিউলের কোডটি এই জায়গাগুলিতে খুঁজবে:
  • ইনলাইন, mod garden-এর পরের সেমিকোলনটির পরিবর্তে কোঁকড়া বন্ধনীর (curly brackets) ভিতরে।
  • src/garden.rs ফাইলে।
  • src/garden/mod.rs ফাইলে।
• সাবমডিউল ডিক্লেয়ার করা: ক্রেট রুট ছাড়া অন্য যেকোনো ফাইলে আপনি সাবমডিউল ডিক্লেয়ার করতে পারেন। উদাহরণস্বরূপ, আপনি হয়তো src/garden.rs ফাইলে mod vegetables; ডিক্লেয়ার করতে পারেন। কম্পাইলার সাবমডিউলের কোডটি প্যারেন্ট মডিউলের নামের ডিরেক্টরিতে এই জায়গাগুলিতে খুঁজবে:
  • ইনলাইন, সরাসরি mod vegetables-এর পরে, সেমিকোলনের পরিবর্তে কোঁকড়া বন্ধনীর ভিতরে।
  • src/garden/vegetables.rs ফাইলে।
  • src/garden/vegetables/mod.rs ফাইলে।
• মডিউলের কোডের পাথ: একবার একটি মডিউল আপনার ক্রেটের অংশ হয়ে গেলে, আপনি সেই ক্রেটের অন্য যেকোনো জায়গা থেকে সেই মডিউলের কোড রেফার করতে পারবেন, যতক্ষণ প্রাইভেসি নিয়ম অনুমতি দেয়, কোডের পাথ ব্যবহার করে। উদাহরণস্বরূপ, garden vegetables মডিউলের একটি Asparagus টাইপ crate::garden::vegetables::Asparagus পাথে পাওয়া যাবে।
• প্রাইভেট বনাম পাবলিক: একটি মডিউলের ভিতরের কোড ডিফল্টরূপে তার প্যারেন্ট মডিউল থেকে প্রাইভেট থাকে। একটি মডিউলকে পাবলিক করতে, mod-এর পরিবর্তে pub mod দিয়ে ডিক্লেয়ার করুন। একটি পাবলিক মডিউলের ভেতরের আইটেমগুলোকেও পাবলিক করতে, তাদের ডিক্লেয়ারেশনের আগে pub ব্যবহার করুন।
• use কীওয়ার্ড: একটি স্কোপের মধ্যে, use কীওয়ার্ড লম্বা পাথের পুনরাবৃত্তি কমাতে আইটেমগুলোর জন্য শর্টকাট তৈরি করে। যেকোনো স্কোপে যেখানে crate::garden::vegetables::Asparagus রেফার করা যায়, আপনি use crate::garden::vegetables::Asparagus; ব্যবহার করে একটি শর্টকাট তৈরি করতে পারেন এবং তারপর থেকে সেই স্কোপে ঐ টাইপটি ব্যবহার করার জন্য আপনাকে কেবল Asparagus লিখতে হবে।

এখানে, আমরা backyard নামে একটি বাইনারি ক্রেট তৈরি করছি যা এই নিয়মগুলি তুলে ধরে। ক্রেটের ডিরেক্টরি, যার নামও backyard, তাতে এই ফাইল এবং ডিরেক্টরিগুলো রয়েছে:

backyard
├── Cargo.lock
├── Cargo.toml
└── src
    ├── garden
    │   └── vegetables.rs
    ├── garden.rs
    └── main.rs

এই ক্ষেত্রে ক্রেট রুট ফাইলটি হলো src/main.rs, এবং এতে রয়েছে:

use crate::garden::vegetables::Asparagus;

pub mod garden;

fn main() {
    let plant = Asparagus {};
    println!("I'm growing {plant:?}!");
}

pub mod garden; লাইনটি কম্পাইলারকে src/garden.rs-এ পাওয়া কোড অন্তর্ভুক্ত করতে বলে, যা হলো:

pub mod vegetables;

এখানে, pub mod vegetables; মানে src/garden/vegetables.rs-এর কোডও অন্তর্ভুক্ত করা হয়েছে। সেই কোডটি হলো:

#[derive(Debug)]
pub struct Asparagus {}

এখন আসুন এই নিয়মগুলির বিস্তারিত বিবরণে যাই এবং সেগুলি বাস্তবে প্রদর্শন করি!

সম্পর্কিত কোডকে মডিউলে গ্রুপিং করা

মডিউল (Modules) আমাদের একটি ক্রেটের মধ্যে পঠনযোগ্যতা (readability) এবং সহজ পুনঃব্যবহারের জন্য কোড অর্গানাইজ করতে দেয়। মডিউল আমাদের আইটেমগুলির প্রাইভেসি (privacy) নিয়ন্ত্রণ করার অনুমতিও দেয় কারণ একটি মডিউলের ভেতরের কোড ডিফল্টরূপে প্রাইভেট থাকে। প্রাইভেট আইটেমগুলো হলো অভ্যন্তরীণ ইমপ্লিমেন্টেশন ডিটেইলস যা বাইরের ব্যবহারের জন্য উপলব্ধ নয়। আমরা মডিউল এবং তার ভেতরের আইটেমগুলোকে পাবলিক করার সিদ্ধান্ত নিতে পারি, যা সেগুলোকে এক্সপোজ করে এবং বাইরের কোডকে সেগুলো ব্যবহার ও তার উপর নির্ভর করার অনুমতি দেয়।

একটি উদাহরণ হিসাবে, চলুন একটি লাইব্রেরি ক্রেট লিখি যা একটি রেস্তোরাঁর কার্যকারিতা প্রদান করে। আমরা ফাংশনের সিগনেচারগুলো ডিফাইন করব কিন্তু তাদের বডি খালি রাখব, যাতে একটি রেস্তোরাঁর ইমপ্লিমেন্টেশনের পরিবর্তে কোডের অর্গানাইজেশনের উপর মনোযোগ দিতে পারি।

রেস্তোরাঁ শিল্পে, একটি রেস্তোরাঁর কিছু অংশকে ফ্রন্ট অফ হাউস (front of house) এবং অন্যগুলোকে ব্যাক অফ হাউস (back of house) বলা হয়। ফ্রন্ট অফ হাউস হলো যেখানে গ্রাহকরা থাকেন; এর মধ্যে রয়েছে যেখানে হোস্টরা গ্রাহকদের বসান, সার্ভাররা অর্ডার এবং পেমেন্ট নেন, এবং বারটেন্ডাররা ড্রিঙ্ক তৈরি করেন। ব্যাক অফ হাউস হলো যেখানে শেফ এবং বাবুর্চিরা রান্নাঘরে কাজ করেন, ডিশওয়াশাররা থালাবাসন পরিষ্কার করেন, এবং ম্যানেজাররা প্রশাসনিক কাজ করেন।

আমাদের ক্রেটকে এইভাবে গঠন করার জন্য, আমরা এর ফাংশনগুলোকে নেস্টেড মডিউলে অর্গানাইজ করতে পারি। cargo new restaurant --lib চালিয়ে restaurant নামে একটি নতুন লাইব্রেরি তৈরি করুন। তারপর কিছু মডিউল এবং ফাংশন সিগনেচার ডিফাইন করতে Listing 7-1-এর কোডটি src/lib.rs-এ লিখুন; এই কোডটি হলো ফ্রন্ট অফ হাউস সেকশন।

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

আমরা mod কীওয়ার্ড এবং তারপরে মডিউলের নাম (এই ক্ষেত্রে, front_of_house) দিয়ে একটি মডিউল ডিফাইন করি। মডিউলের বডি তখন কোঁকড়া বন্ধনীর ভিতরে যায়। মডিউলের ভিতরে, আমরা অন্য মডিউল রাখতে পারি, যেমন এই ক্ষেত্রে hosting এবং serving মডিউল। মডিউল অন্যান্য আইটেম, যেমন struct, enum, constant, trait এবং Listing 7-1-এর মতো ফাংশনের ডেফিনিশনও রাখতে পারে।

মডিউল ব্যবহার করে, আমরা সম্পর্কিত ডেফিনিশনগুলোকে একসাথে গ্রুপ করতে পারি এবং কেন তারা সম্পর্কিত তার নামকরণ করতে পারি। এই কোড ব্যবহারকারী প্রোগ্রামাররা সমস্ত ডেফিনিশন পড়ার পরিবর্তে গ্রুপগুলোর উপর ভিত্তি করে কোড নেভিগেট করতে পারবেন, যা তাদের জন্য প্রাসঙ্গিক ডেফিনিশন খুঁজে পাওয়া সহজ করে তোলে। যে প্রোগ্রামাররা এই কোডে নতুন ফাংশনালিটি যোগ করবেন, তারা জানবেন প্রোগ্রামকে অর্গানাইজড রাখতে কোডটি কোথায় রাখতে হবে।

পূর্বে, আমরা উল্লেখ করেছি যে src/main.rs এবং src/lib.rs-কে ক্রেট রুট বলা হয়। তাদের এই নামের কারণ হলো এই দুটি ফাইলের বিষয়বস্তু ক্রেটের মডিউল স্ট্রাকচারের রুটে crate নামে একটি মডিউল তৈরি করে, যা মডিউল ট্রি (module tree) নামে পরিচিত।

Listing 7-2, Listing 7-1-এর স্ট্রাকচারের জন্য মডিউল ট্রি দেখায়।

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

এই ট্রি দেখায় কিভাবে কিছু মডিউল অন্য মডিউলের ভিতরে নেস্ট করা আছে; উদাহরণস্বরূপ, hosting front_of_house-এর ভিতরে নেস্ট করা। ট্রি এটিও দেখায় যে কিছু মডিউল সিবলিং (siblings), যার মানে তারা একই মডিউলে ডিফাইন করা হয়েছে; hosting এবং serving হলো front_of_house-এর মধ্যে ডিফাইন করা সিবলিং। যদি মডিউল A মডিউল B-এর ভিতরে থাকে, আমরা বলি যে মডিউল A হলো মডিউল B-এর চাইল্ড (child) এবং মডিউল B হলো মডিউল A-এর প্যারেন্ট (parent)। লক্ষ্য করুন যে পুরো মডিউল ট্রি-টি crate নামের একটি অন্তর্নিহিত (implicit) মডিউলের অধীনে রুট করা হয়েছে।

মডিউল ট্রি আপনাকে আপনার কম্পিউটারের ফাইলসিস্টেমের ডিরেক্টরি ট্রি-এর কথা মনে করিয়ে দিতে পারে; এটি একটি খুব উপযুক্ত তুলনা! ফাইলসিস্টেমের ডিরেক্টরির মতো, আপনি আপনার কোড অর্গানাইজ করতে মডিউল ব্যবহার করেন। এবং একটি ডিরেক্টরিতে ফাইলের মতো, আমাদের মডিউলগুলো খুঁজে বের করার একটি উপায় প্রয়োজন।

মডিউল ট্রি-তে কোনো আইটেম রেফার করার জন্য পাথ

মডিউল ট্রি-তে কোনো আইটেম রাস্টকে কোথায় খুঁজে পাবে তা দেখানোর জন্য, আমরা একটি পাথ (path) ব্যবহার করি, ঠিক যেমন আমরা ফাইলসিস্টেম নেভিগেট করার সময় পাথ ব্যবহার করি। একটি ফাংশন কল করার জন্য, আমাদের তার পাথ জানতে হবে।

একটি পাথ দুই ধরনের হতে পারে:

• একটি অ্যাবসোলিউট পাথ (absolute path) হলো ক্রেট রুট থেকে শুরু হওয়া সম্পূর্ণ পাথ; এক্সটার্নাল ক্রেট থেকে আসা কোডের জন্য অ্যাবসোলিউট পাথ ক্রেটের নাম দিয়ে শুরু হয়, এবং বর্তমান ক্রেটের কোডের জন্য এটি crate লিটারেল দিয়ে শুরু হয়।
• একটি রিলেটিভ পাথ (relative path) বর্তমান মডিউল থেকে শুরু হয় এবং self, super বা বর্তমান মডিউলের কোনো আইডেন্টিফায়ার ব্যবহার করে।

অ্যাবসোলিউট এবং রিলেটিভ উভয় পাথই এক বা একাধিক আইডেন্টিফায়ার দ্বারা অনুসরণ করা হয় যা ডাবল কোলন (::) দ্বারা বিভক্ত থাকে।

Listing 7-1-এ ফিরে আসা যাক, ধরুন আমরা add_to_waitlist ফাংশনটি কল করতে চাই। এটি জিজ্ঞেস করার মতোই: add_to_waitlist ফাংশনের পাথ কী? Listing 7-3-এ Listing 7-1-এর কিছু মডিউল এবং ফাংশন বাদ দিয়ে দেখানো হয়েছে।

আমরা ক্রেট রুটে ডিফাইন করা একটি নতুন ফাংশন eat_at_restaurant থেকে add_to_waitlist ফাংশনটি কল করার দুটি উপায় দেখাব। এই পাথগুলো সঠিক, কিন্তু আরেকটি সমস্যা রয়েছে যা এই উদাহরণটিকে কম্পাইল হতে বাধা দেবে। আমরা একটু পরেই ব্যাখ্যা করব কেন।

eat_at_restaurant ফাংশনটি আমাদের লাইব্রেরি ক্রেটের পাবলিক API-এর অংশ, তাই আমরা এটিকে pub কীওয়ার্ড দিয়ে চিহ্নিত করেছি। "pub কীওয়ার্ড দিয়ে পাথ এক্সপোজ করা” বিভাগে, আমরা pub সম্পর্কে আরও বিস্তারিত আলোচনা করব।

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

eat_at_restaurant-এ প্রথমবার যখন আমরা add_to_waitlist ফাংশনটি কল করি, আমরা একটি অ্যাবসোলিউট পাথ ব্যবহার করি। add_to_waitlist ফাংশনটি eat_at_restaurant-এর একই ক্রেটে ডিফাইন করা হয়েছে, যার মানে আমরা একটি অ্যাবসোলিউট পাথ শুরু করতে crate কীওয়ার্ডটি ব্যবহার করতে পারি। এরপর আমরা add_to_waitlist পর্যন্ত পৌঁছানোর জন্য প্রতিটি মডিউলকে ক্রমানুসারে অন্তর্ভুক্ত করি। আপনি একই কাঠামোর একটি ফাইলসিস্টেম কল্পনা করতে পারেন: আমরা add_to_waitlist প্রোগ্রামটি চালানোর জন্য /front_of_house/hosting/add_to_waitlist পাথটি নির্দিষ্ট করতাম; ক্রেট রুট থেকে শুরু করার জন্য crate নামটি ব্যবহার করা আপনার শেলের ফাইলসিস্টেম রুট থেকে শুরু করার জন্য / ব্যবহার করার মতো।

eat_at_restaurant-এ দ্বিতীয়বার যখন আমরা add_to_waitlist কল করি, আমরা একটি রিলেটিভ পাথ ব্যবহার করি। পাথটি front_of_house দিয়ে শুরু হয়, যা eat_at_restaurant-এর মতো মডিউল ট্রি-এর একই লেভেলে ডিফাইন করা মডিউলের নাম। এখানে ফাইলসিস্টেমের সমতুল্য হবে front_of_house/hosting/add_to_waitlist পাথটি ব্যবহার করা। একটি মডিউলের নাম দিয়ে শুরু করার মানে হলো পাথটি রিলেটিভ।

রিলেটিভ বা অ্যাবসোলিউট পাথ ব্যবহার করবেন কিনা, সেই সিদ্ধান্তটি আপনি আপনার প্রজেক্টের উপর ভিত্তি করে নেবেন এবং এটি নির্ভর করে আপনি আইটেম ডেফিনিশন কোডটি আইটেম ব্যবহারকারী কোডের সাথে একসাথে নাকি আলাদাভাবে সরানোর সম্ভাবনা বেশি তার উপর। উদাহরণস্বরূপ, যদি আমরা front_of_house মডিউল এবং eat_at_restaurant ফাংশনটিকে customer_experience নামের একটি মডিউলে স্থানান্তর করি, তাহলে আমাদের add_to_waitlist-এর অ্যাবসোলিউট পাথ আপডেট করতে হবে, কিন্তু রিলেটিভ পাথটি তখনও বৈধ থাকবে। তবে, যদি আমরা eat_at_restaurant ফাংশনটিকে আলাদাভাবে dining নামের একটি মডিউলে স্থানান্তর করি, তাহলে add_to_waitlist কলের অ্যাবসোলিউট পাথ একই থাকবে, কিন্তু রিলেটিভ পাথ আপডেট করতে হবে। আমাদের সাধারণ পছন্দ হলো অ্যাবসোলিউট পাথ নির্দিষ্ট করা, কারণ কোড ডেফিনিশন এবং আইটেম কল একে অপরের থেকে স্বাধীনভাবে সরানোর প্রয়োজন হওয়ার সম্ভাবনা বেশি।

চলুন Listing 7-3 কম্পাইল করার চেষ্টা করি এবং খুঁজে বের করি কেন এটি এখনও কম্পাইল হবে না! আমরা যে এররগুলো পাই তা Listing 7-4-এ দেখানো হয়েছে।

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: module `hosting` is private
 --> src/lib.rs:9:28
  |
9 |     crate::front_of_house::hosting::add_to_waitlist();
  |                            ^^^^^^^  --------------- function `add_to_waitlist` is not publicly re-exported
  |                            |
  |                            private module
  |
note: the module `hosting` is defined here
 --> src/lib.rs:2:5
  |
2 |     mod hosting {
  |     ^^^^^^^^^^^

error[E0603]: module `hosting` is private
  --> src/lib.rs:12:21
   |
12 |     front_of_house::hosting::add_to_waitlist();
   |                     ^^^^^^^  --------------- function `add_to_waitlist` is not publicly re-exported
   |                     |
   |                     private module
   |
note: the module `hosting` is defined here
  --> src/lib.rs:2:5
   |
2  |     mod hosting {
   |     ^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` (lib) due to 2 previous errors

এরর মেসেজগুলো বলছে যে hosting মডিউলটি প্রাইভেট। অন্য কথায়, hosting মডিউল এবং add_to_waitlist ফাংশনের জন্য আমাদের কাছে সঠিক পাথ রয়েছে, কিন্তু রাস্ট আমাদের সেগুলি ব্যবহার করতে দেবে না কারণ এটি প্রাইভেট সেকশন অ্যাক্সেস করতে পারে না। রাস্ট-এ, সমস্ত আইটেম (ফাংশন, মেথড, struct, enum, মডিউল, এবং ধ্রুবক) ডিফল্টরূপে প্যারেন্ট মডিউলের কাছে প্রাইভেট থাকে। আপনি যদি কোনো ফাংশন বা struct-এর মতো আইটেমকে প্রাইভেট করতে চান তবে সেটিকে একটি মডিউলের মধ্যে রাখুন।

প্যারেন্ট মডিউলের আইটেমগুলো চাইল্ড মডিউলের ভিতরের প্রাইভেট আইটেম ব্যবহার করতে পারে না, কিন্তু চাইল্ড মডিউলের আইটেমগুলো তাদের পূর্বপুরুষ (ancestor) মডিউলের আইটেম ব্যবহার করতে পারে। এর কারণ হলো চাইল্ড মডিউলগুলো তাদের ইমপ্লিমেন্টেশন ডিটেইলসকে র‍্যাপ করে এবং লুকিয়ে রাখে, কিন্তু চাইল্ড মডিউলগুলো যে কনটেক্সটে ডিফাইন করা হয়েছে তা দেখতে পারে। আমাদের রূপকটি চালিয়ে যেতে, প্রাইভেসি নিয়মগুলোকে একটি রেস্তোরাঁর ব্যাক অফিসের মতো ভাবুন: সেখানে যা ঘটে তা রেস্তোরাঁর গ্রাহকদের কাছে প্রাইভেট, কিন্তু অফিস ম্যানেজাররা তাদের পরিচালিত রেস্তোরাঁর সবকিছু দেখতে এবং করতে পারেন।

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

pub কীওয়ার্ড দিয়ে পাথ এক্সপোজ করা

আসুন Listing 7-4-এর এররটিতে ফিরে যাই যা আমাদের বলেছিল যে hosting মডিউলটি প্রাইভেট। আমরা চাই প্যারেন্ট মডিউলের eat_at_restaurant ফাংশনটি চাইল্ড মডিউলের add_to_waitlist ফাংশনটি অ্যাক্সেস করুক, তাই আমরা hosting মডিউলটিকে pub কীওয়ার্ড দিয়ে চিহ্নিত করি, যেমনটি Listing 7-5-এ দেখানো হয়েছে।

mod front_of_house {
    pub mod hosting {
        fn add_to_waitlist() {}
    }
}

// -- snip --
pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

দুর্ভাগ্যবশত, Listing 7-5-এর কোডটি এখনও কম্পাইলার এরর দেয়, যেমনটি Listing 7-6-এ দেখানো হয়েছে।

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: function `add_to_waitlist` is private
  --> src/lib.rs:10:37
   |
10 |     crate::front_of_house::hosting::add_to_waitlist();
   |                                     ^^^^^^^^^^^^^^^ private function
   |
note: the function `add_to_waitlist` is defined here
  --> src/lib.rs:3:9
   |
3  |         fn add_to_waitlist() {}
   |         ^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `add_to_waitlist` is private
  --> src/lib.rs:13:30
   |
13 |     front_of_house::hosting::add_to_waitlist();
   |                              ^^^^^^^^^^^^^^^ private function
   |
note: the function `add_to_waitlist` is defined here
  --> src/lib.rs:3:9
   |
3  |         fn add_to_waitlist() {}
   |         ^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` (lib) due to 2 previous errors

কী হলো? mod hosting-এর সামনে pub কীওয়ার্ড যুক্ত করা মডিউলটিকে পাবলিক করে। এই পরিবর্তনের ফলে, যদি আমরা front_of_house অ্যাক্সেস করতে পারি, আমরা hosting অ্যাক্সেস করতে পারব। কিন্তু hosting-এর ভেতরের বিষয়বস্তু এখনও প্রাইভেট; মডিউলকে পাবলিক করা তার ভেতরের বিষয়বস্তুকে পাবলিক করে না। একটি মডিউলের উপর pub কীওয়ার্ড শুধুমাত্র তার পূর্বপুরুষ মডিউলের কোডকে এটি রেফার করার অনুমতি দেয়, এর ভেতরের কোড অ্যাক্সেস করার অনুমতি দেয় না। যেহেতু মডিউল হলো কন্টেইনার, শুধুমাত্র মডিউলটিকে পাবলিক করে আমরা খুব বেশি কিছু করতে পারি না; আমাদের আরও এগিয়ে যেতে হবে এবং মডিউলের ভেতরের এক বা একাধিক আইটেমকেও পাবলিক করতে হবে।

Listing 7-6-এর এররগুলো বলছে যে add_to_waitlist ফাংশনটি প্রাইভেট। প্রাইভেসি নিয়ম struct, enum, ফাংশন, এবং মেথডের পাশাপাশি মডিউলের ক্ষেত্রেও প্রযোজ্য।

আসুন add_to_waitlist ফাংশনটিকেও পাবলিক করি তার ডেফিনিশনের আগে pub কীওয়ার্ড যোগ করে, যেমন Listing 7-7-এ দেখানো হয়েছে।

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// -- snip --
pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

এখন কোডটি কম্পাইল হবে! প্রাইভেসি নিয়মের সাপেক্ষে pub কীওয়ার্ড যোগ করা কেন আমাদের eat_at_restaurant-এ এই পাথগুলো ব্যবহার করতে দেয় তা দেখতে, আসুন অ্যাবসোলিউট এবং রিলেটিভ পাথগুলো দেখি।

অ্যাবসোলিউট পাথে, আমরা crate দিয়ে শুরু করি, যা আমাদের ক্রেটের মডিউল ট্রি-এর রুট। front_of_house মডিউলটি ক্রেট রুটে ডিফাইন করা হয়েছে। যদিও front_of_house পাবলিক নয়, কারণ eat_at_restaurant ফাংশনটি front_of_house-এর মতো একই মডিউলে ডিফাইন করা হয়েছে (অর্থাৎ, eat_at_restaurant এবং front_of_house সিবলিং), আমরা eat_at_restaurant থেকে front_of_house রেফার করতে পারি। এরপরে hosting মডিউলটি pub দিয়ে চিহ্নিত করা হয়েছে। আমরা hosting-এর প্যারেন্ট মডিউল অ্যাক্সেস করতে পারি, তাই আমরা hosting অ্যাক্সেস করতে পারি। অবশেষে, add_to_waitlist ফাংশনটি pub দিয়ে চিহ্নিত এবং আমরা তার প্যারেন্ট মডিউল অ্যাক্সেস করতে পারি, তাই এই ফাংশন কলটি কাজ করে!

রিলেটিভ পাথে, প্রথম ধাপ ছাড়া যুক্তিটি অ্যাবসোলিউট পাথের মতোই: ক্রেট রুট থেকে শুরু না করে পাথটি front_of_house থেকে শুরু হয়। front_of_house মডিউলটি eat_at_restaurant-এর মতো একই মডিউলের মধ্যে ডিফাইন করা হয়েছে, তাই eat_at_restaurant যে মডিউলে ডিফাইন করা হয়েছে সেখান থেকে শুরু হওয়া রিলেটিভ পাথটি কাজ করে। তারপর, যেহেতু hosting এবং add_to_waitlist pub দিয়ে চিহ্নিত করা হয়েছে, বাকি পাথ কাজ করে, এবং এই ফাংশন কলটি বৈধ!

আপনি যদি আপনার লাইব্রেরি ক্রেট শেয়ার করার পরিকল্পনা করেন যাতে অন্যান্য প্রজেক্ট আপনার কোড ব্যবহার করতে পারে, আপনার পাবলিক API হলো আপনার ক্রেটের ব্যবহারকারীদের সাথে আপনার চুক্তি যা নির্ধারণ করে তারা কীভাবে আপনার কোডের সাথে ইন্টারঅ্যাক্ট করতে পারে। আপনার পাবলিক API-তে পরিবর্তনগুলি পরিচালনা করার বিষয়ে অনেক বিবেচনা রয়েছে যাতে লোকেরা আপনার ক্রেটের উপর নির্ভর করতে পারে। এই বিবেচনাগুলো এই বইয়ের আওতার বাইরে; আপনি যদি এই বিষয়ে আগ্রহী হন, তাহলে The Rust API Guidelines দেখুন।

একটি বাইনারি এবং একটি লাইব্রেরি সহ প্যাকেজের জন্য সেরা অভ্যাস

আমরা উল্লেখ করেছি যে একটি প্যাকেজে একটি src/main.rs বাইনারি ক্রেট রুট এবং একটি src/lib.rs লাইব্রেরি ক্রেট রুট উভয়ই থাকতে পারে, এবং উভয় ক্রেটের নাম ডিফল্টরূপে প্যাকেজের নাম হবে। সাধারণত, এই প্যাটার্নের প্যাকেজগুলোতে, যেখানে একটি লাইব্রেরি এবং একটি বাইনারি উভয় ক্রেটই থাকে, বাইনারি ক্রেটে কেবল লাইব্রেরি ক্রেটে সংজ্ঞায়িত কোড কল করে একটি এক্সিকিউটেবল শুরু করার জন্য যথেষ্ট কোড থাকে। এটি অন্যান্য প্রজেক্টকে প্যাকেজের提供的 কার্যকারিতা থেকে উপকৃত হতে দেয় কারণ লাইব্রেরি ক্রেটের কোড শেয়ার করা যেতে পারে।

মডিউল ট্রি src/lib.rs-এ ডিফাইন করা উচিত। তারপরে, যেকোনো পাবলিক আইটেম বাইনারি ক্রেটে প্যাকেজের নাম দিয়ে পাথ শুরু করে ব্যবহার করা যেতে পারে। বাইনারি ক্রেটটি লাইব্রেরি ক্রেটের একজন ব্যবহারকারী হয়ে ওঠে ঠিক যেমন একটি সম্পূর্ণ এক্সটার্নাল ক্রেট লাইব্রেরি ক্রেট ব্যবহার করবে: এটি কেবল পাবলিক API ব্যবহার করতে পারে। এটি আপনাকে একটি ভাল API ডিজাইন করতে সাহায্য করে; আপনি কেবল লেখকই নন, আপনি একজন ক্লায়েন্টও!

অধ্যায় ১২-এ, আমরা একটি কমান্ড লাইন প্রোগ্রামের সাথে এই সাংগঠনিক অনুশীলনটি প্রদর্শন করব যা একটি বাইনারি ক্রেট এবং একটি লাইব্রেরি ক্রেট উভয়ই ধারণ করবে।

super দিয়ে রিলেটিভ পাথ শুরু করা

আমরা super ব্যবহার করে রিলেটিভ পাথ তৈরি করতে পারি যা বর্তমান মডিউল বা ক্রেট রুটের পরিবর্তে প্যারেন্ট মডিউলে শুরু হয়। এটি ফাইলসিস্টেম পাথ .. সিনট্যাক্স দিয়ে শুরু করার মতো, যার মানে হলো প্যারেন্ট ডিরেক্টরিতে যাওয়া। super ব্যবহার করে আমরা এমন একটি আইটেম রেফারেন্স করতে পারি যা আমরা জানি প্যারেন্ট মডিউলে আছে, যা মডিউল ট্রি পুনর্বিন্যাস করা সহজ করে তুলতে পারে যখন মডিউলটি প্যারেন্টের সাথে ঘনিষ্ঠভাবে সম্পর্কিত কিন্তু প্যারেন্টকে ভবিষ্যতে মডিউল ট্রি-এর অন্য কোথাও সরানো হতে পারে।

Listing 7-8-এর কোডটি বিবেচনা করুন যা এমন একটি পরিস্থিতি মডেল করে যেখানে একজন শেফ একটি ভুল অর্ডার ঠিক করে এবং ব্যক্তিগতভাবে গ্রাহকের কাছে নিয়ে আসে। back_of_house মডিউলে ডিফাইন করা fix_incorrect_order ফাংশনটি super দিয়ে শুরু হওয়া deliver_order-এর পাথ নির্দিষ্ট করে প্যারেন্ট মডিউলে ডিফাইন করা deliver_order ফাংশনটিকে কল করে।

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

fix_incorrect_order ফাংশনটি back_of_house মডিউলে রয়েছে, তাই আমরা super ব্যবহার করে back_of_house-এর প্যারেন্ট মডিউলে যেতে পারি, যা এক্ষেত্রে crate, অর্থাৎ রুট। সেখান থেকে আমরা deliver_order খুঁজি এবং এটি খুঁজে পাই। সফল! আমরা মনে করি back_of_house মডিউল এবং deliver_order ফাংশনটি একে অপরের সাথে একই সম্পর্কে থাকার সম্ভাবনা রয়েছে এবং যদি আমরা ক্রেটের মডিউল ট্রি পুনর্বিন্যাস করার সিদ্ধান্ত নিই তবে একসাথে সরানো হবে। তাই, আমরা super ব্যবহার করেছি যাতে ভবিষ্যতে এই কোডটি অন্য মডিউলে সরানো হলে আমাদের কম জায়গায় কোড আপডেট করতে হয়।

Struct এবং Enum-কে পাবলিক করা

আমরা pub ব্যবহার করে struct এবং enum-কে পাবলিক হিসাবে মনোনীত করতে পারি, কিন্তু struct এবং enum-এর সাথে pub-এর ব্যবহারে কিছু অতিরিক্ত বিবরণ রয়েছে। যদি আমরা একটি struct ডেফিনিশনের আগে pub ব্যবহার করি, আমরা struct-টিকে পাবলিক করি, কিন্তু struct-এর ফিল্ডগুলো তখনও প্রাইভেট থাকবে। আমরা প্রতিটি ফিল্ডকে কেস-বাই-কেস ভিত্তিতে পাবলিক বা নট পাবলিক করতে পারি। Listing 7-9-এ, আমরা একটি পাবলিক toast ফিল্ড এবং একটি প্রাইভেট seasonal_fruit ফিল্ড সহ একটি পাবলিক back_of_house::Breakfast struct ডিফাইন করেছি। এটি একটি রেস্তোরাঁর পরিস্থিতি মডেল করে যেখানে গ্রাহক খাবারের সাথে আসা রুটির ধরন বেছে নিতে পারেন, কিন্তু শেফ সিদ্ধান্ত নেন কোন ফলটি খাবারের সাথে পরিবেশন করা হবে, যা ঋতু এবং স্টকের উপর ভিত্তি করে নির্ধারিত হয়। উপলব্ধ ফল দ্রুত পরিবর্তিত হয়, তাই গ্রাহকরা ফল বেছে নিতে বা এমনকি তারা কোন ফল পাবেন তা দেখতেও পারেন না।

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // Order a breakfast in the summer with Rye toast.
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // Change our mind about what bread we'd like.
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);

    // The next line won't compile if we uncomment it; we're not allowed
    // to see or modify the seasonal fruit that comes with the meal.
    // meal.seasonal_fruit = String::from("blueberries");
}

যেহেতু back_of_house::Breakfast struct-এর toast ফিল্ডটি পাবলিক, তাই eat_at_restaurant-এ আমরা ডট নোটেশন ব্যবহার করে toast ফিল্ডে লিখতে এবং পড়তে পারি। লক্ষ্য করুন যে আমরা eat_at_restaurant-এ seasonal_fruit ফিল্ডটি ব্যবহার করতে পারি না, কারণ seasonal_fruit প্রাইভেট। seasonal_fruit ফিল্ডের মান পরিবর্তনকারী লাইনটি আনকমেন্ট করে চেষ্টা করুন কী এরর পান তা দেখতে!

এছাড়াও, লক্ষ্য করুন যে যেহেতু back_of_house::Breakfast-এর একটি প্রাইভেট ফিল্ড আছে, তাই struct-টিকে একটি পাবলিক অ্যাসোসিয়েটেড ফাংশন সরবরাহ করতে হবে যা Breakfast-এর একটি ইনস্ট্যান্স তৈরি করে (আমরা এখানে এটির নাম দিয়েছি summer)। যদি Breakfast-এর এমন কোনো ফাংশন না থাকত, আমরা eat_at_restaurant-এ Breakfast-এর একটি ইনস্ট্যান্স তৈরি করতে পারতাম না কারণ আমরা eat_at_restaurant-এ প্রাইভেট seasonal_fruit ফিল্ডের মান সেট করতে পারতাম না।

এর বিপরীতে, যদি আমরা একটি enum-কে পাবলিক করি, তবে এর সমস্ত ভ্যারিয়েন্ট তখন পাবলিক হয়ে যায়। আমাদের কেবল enum কীওয়ার্ডের আগে pub প্রয়োজন, যেমনটি Listing 7-10-এ দেখানো হয়েছে।

mod back_of_house {
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}

যেহেতু আমরা Appetizer enum-কে পাবলিক করেছি, তাই আমরা eat_at_restaurant-এ Soup এবং Salad ভ্যারিয়েন্টগুলো ব্যবহার করতে পারি।

Enum-গুলো খুব একটা কাজের নয় যদি না তাদের ভ্যারিয়েন্টগুলো পাবলিক হয়; প্রতি ক্ষেত্রে সমস্ত enum ভ্যারিয়েন্টকে pub দিয়ে অ্যানোটেট করা বিরক্তিকর হবে, তাই enum ভ্যারিয়েন্টের জন্য ডিফল্ট হলো পাবলিক হওয়া। Struct-গুলো প্রায়শই তাদের ফিল্ড পাবলিক না হয়েও দরকারী, তাই struct ফিল্ডগুলো pub দিয়ে অ্যানোটেট না করা পর্যন্ত ডিফল্টরূপে সবকিছু প্রাইভেট থাকার সাধারণ নিয়ম অনুসরণ করে।

pub-কে জড়িত করে আরও একটি পরিস্থিতি রয়েছে যা আমরা এখনও কভার করিনি, এবং সেটি হলো আমাদের শেষ মডিউল সিস্টেম ফিচার: use কীওয়ার্ড। আমরা প্রথমে use নিয়ে একা আলোচনা করব, এবং তারপর আমরা দেখাব কিভাবে pub এবং use একত্রিত করা যায়।

use কীওয়ার্ড ব্যবহার করে স্কোপে পাথ নিয়ে আসা

ফাংশন কল করার জন্য বারবার পুরো পাথ লেখাটা বেশ অসুবিধাজনক এবং পুনরাবৃত্তিমূলক মনে হতে পারে। Listing 7-7-এ, আমরা add_to_waitlist ফাংশনের জন্য অ্যাবসোলিউট বা রিলেটিভ পাথ যাই বেছে নিই না কেন, প্রতিবার add_to_waitlist কল করার সময় আমাদের front_of_house এবং hosting-ও নির্দিষ্ট করতে হয়েছিল। সৌভাগ্যবশত, এই প্রক্রিয়াটি সহজ করার একটি উপায় আছে: আমরা use কীওয়ার্ড দিয়ে একবার একটি পাথের শর্টকাট তৈরি করে নিতে পারি এবং তারপর স্কোপের অন্য সব জায়গায় ছোট নামটি ব্যবহার করতে পারি।

Listing 7-11-এ, আমরা crate::front_of_house::hosting মডিউলটিকে eat_at_restaurant ফাংশনের স্কোপে নিয়ে এসেছি, তাই eat_at_restaurant-এর মধ্যে add_to_waitlist ফাংশনটি কল করার জন্য আমাদের কেবল hosting::add_to_waitlist নির্দিষ্ট করতে হবে।

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

একটি স্কোপে use এবং একটি পাথ যোগ করা ফাইলসিস্টেমে একটি সিম্বলিক লিঙ্ক তৈরি করার মতো। ক্রেট রুটে use crate::front_of_house::hosting যোগ করার মাধ্যমে, hosting এখন সেই স্কোপে একটি বৈধ নাম, ঠিক যেন hosting মডিউলটি ক্রেট রুটেই ডিফাইন করা হয়েছিল। use দিয়ে স্কোপে আনা পাথগুলোও অন্য যেকোনো পাথের মতোই প্রাইভেসি পরীক্ষা করে।

মনে রাখবেন যে use শুধুমাত্র সেই নির্দিষ্ট স্কোপের জন্য শর্টকাট তৈরি করে যেখানে use ব্যবহার করা হয়েছে। Listing 7-12-এ eat_at_restaurant ফাংশনটিকে customer নামের একটি নতুন চাইল্ড মডিউলে সরানো হয়েছে, যা use স্টেটমেন্টের থেকে ভিন্ন একটি স্কোপ, তাই ফাংশনের বডি কম্পাইল হবে না।

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

mod customer {
    pub fn eat_at_restaurant() {
        hosting::add_to_waitlist();
    }
}

কম্পাইলার এরর দেখায় যে শর্টকাটটি আর customer মডিউলের মধ্যে প্রযোজ্য নয়:

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0433]: failed to resolve: use of undeclared crate or module `hosting`
  --> src/lib.rs:11:9
   |
11 |         hosting::add_to_waitlist();
   |         ^^^^^^^ use of undeclared crate or module `hosting`
   |
help: consider importing this module through its public re-export
   |
10 +     use crate::hosting;
   |

warning: unused import: `crate::front_of_house::hosting`
 --> src/lib.rs:7:5
  |
7 | use crate::front_of_house::hosting;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0433`.
warning: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` (lib) due to 1 previous error; 1 warning emitted

লক্ষ্য করুন, একটি ওয়ার্নিংও রয়েছে যে use তার স্কোপে আর ব্যবহৃত হচ্ছে না! এই সমস্যাটি সমাধান করার জন্য, use-কে customer মডিউলের ভিতরেও সরিয়ে নিন, অথবা চাইল্ড customer মডিউলের মধ্যে প্যারেন্ট মডিউলের শর্টকাটটিকে super::hosting দিয়ে রেফারেন্স করুন।

প্রচলিত use পাথ তৈরি করা

Listing 7-11-এ, আপনি হয়তো ভেবেছিলেন কেন আমরা use crate::front_of_house::hosting নির্দিষ্ট করেছি এবং তারপর eat_at_restaurant-এ hosting::add_to_waitlist কল করেছি, যেখানে আমরা use পাথটিকে add_to_waitlist ফাংশন পর্যন্ত প্রসারিত করে একই ফলাফল অর্জন করতে পারতাম, যেমনটি Listing 7-13-এ দেখানো হয়েছে।

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting::add_to_waitlist;

pub fn eat_at_restaurant() {
    add_to_waitlist();
}

যদিও Listing 7-11 এবং Listing 7-13 উভয়ই একই কাজ সম্পন্ন করে, use দিয়ে একটি ফাংশনকে স্কোপে আনার প্রচলিত (idiomatic) উপায় হলো Listing 7-11। use দিয়ে ফাংশনের প্যারেন্ট মডিউলকে স্কোপে আনার মানে হলো ফাংশনটি কল করার সময় আমাদের প্যারেন্ট মডিউলটি নির্দিষ্ট করতে হবে। ফাংশন কল করার সময় প্যারেন্ট মডিউল নির্দিষ্ট করা এটা স্পষ্ট করে যে ফাংশনটি স্থানীয়ভাবে ডিফাইন করা হয়নি, এবং একই সাথে সম্পূর্ণ পাথের পুনরাবৃত্তিও কমায়। Listing 7-13-এর কোডটি অস্পষ্ট কারণ add_to_waitlist কোথায় ডিফাইন করা হয়েছে তা বোঝা যায় না।

অন্যদিকে, use দিয়ে struct, enum এবং অন্যান্য আইটেম আনার সময়, সম্পূর্ণ পাথ নির্দিষ্ট করাই প্রচলিত রীতি। Listing 7-14 স্ট্যান্ডার্ড লাইব্রেরির HashMap struct-কে একটি বাইনারি ক্রেটের স্কোপে আনার প্রচলিত উপায় দেখায়।

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

এই রীতির পিছনে কোনো শক্তিশালী কারণ নেই: এটি কেবল একটি কনভেনশন যা সময়ের সাথে তৈরি হয়েছে, এবং লোকেরা এইভাবেই রাস্ট কোড পড়তে এবং লিখতে অভ্যস্ত হয়ে গেছে।

এই রীতির ব্যতিক্রম হলো যদি আমরা use স্টেটমেন্ট ব্যবহার করে একই নামের দুটি আইটেমকে স্কোপে নিয়ে আসি, কারণ রাস্ট এটির অনুমতি দেয় না। Listing 7-15 দেখায় কিভাবে একই নামের কিন্তু ভিন্ন প্যারেন্ট মডিউলের দুটি Result টাইপকে স্কোপে আনা যায় এবং কীভাবে তাদের রেফার করতে হয়।

use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn function2() -> io::Result<()> {
    // --snip--
    Ok(())
}

আপনি দেখতে পাচ্ছেন, প্যারেন্ট মডিউল ব্যবহার করে দুটি Result টাইপকে আলাদা করা হয়েছে। যদি আমরা use std::fmt::Result এবং use std::io::Result নির্দিষ্ট করতাম, তাহলে আমাদের একই স্কোপে দুটি Result টাইপ থাকত, এবং যখন আমরা Result ব্যবহার করতাম, রাস্ট জানত না আমরা কোনটি বোঝাতে চাইছি।

as কীওয়ার্ড দিয়ে নতুন নাম প্রদান করা

use দিয়ে একই নামের দুটি টাইপকে একই স্কোপে আনার সমস্যার আরেকটি সমাধান আছে: পাথের পরে, আমরা as এবং টাইপের জন্য একটি নতুন স্থানীয় নাম বা alias নির্দিষ্ট করতে পারি। Listing 7-16-এ, Listing 7-15-এর কোডটি লেখার আরেকটি উপায় দেখানো হয়েছে, যেখানে as ব্যবহার করে দুটি Result টাইপের মধ্যে একটির নাম পরিবর্তন করা হয়েছে।

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
    Ok(())
}

fn function2() -> IoResult<()> {
    // --snip--
    Ok(())
}

দ্বিতীয় use স্টেটমেন্টে, আমরা std::io::Result টাইপের জন্য নতুন নাম IoResult বেছে নিয়েছি, যা std::fmt থেকে আনা Result-এর সাথে冲突 করবে না, যেটিও আমরা স্কোপে নিয়ে এসেছি। Listing 7-15 এবং Listing 7-16 উভয়ই প্রচলিত হিসাবে বিবেচিত হয়, তাই পছন্দ আপনার!

pub use দিয়ে নাম পুনরায়-এক্সপোর্ট করা

যখন আমরা use কীওয়ার্ড দিয়ে একটি নামকে স্কোপে নিয়ে আসি, তখন নামটি সেই স্কোপের জন্য প্রাইভেট থাকে যেখানে আমরা এটি ইম্পোর্ট করেছি। সেই স্কোপের বাইরের কোডকে সেই নামটি এমনভাবে রেফার করতে সক্ষম করার জন্য যেন এটি সেই স্কোপেই ডিফাইন করা হয়েছিল, আমরা pub এবং use একত্রিত করতে পারি। এই কৌশলটিকে রি-এক্সপোর্টিং (re-exporting) বলা হয় কারণ আমরা একটি আইটেমকে স্কোপে নিয়ে আসছি এবং একই সাথে সেই আইটেমটিকে অন্যদের তাদের স্কোপে আনার জন্য উপলব্ধ করে দিচ্ছি।

Listing 7-17-এ Listing 7-11-এর কোডটি দেখানো হয়েছে যেখানে রুট মডিউলের use-কে pub use-এ পরিবর্তন করা হয়েছে।

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

এই পরিবর্তনের আগে, এক্সটার্নাল কোডকে restaurant::front_of_house::hosting::add_to_waitlist() পাথ ব্যবহার করে add_to_waitlist ফাংশনটি কল করতে হতো, যার জন্য front_of_house মডিউলটিকেও pub হিসাবে চিহ্নিত করার প্রয়োজন হতো। এখন যেহেতু এই pub use রুট মডিউল থেকে hosting মডিউলটিকে রি-এক্সপোর্ট করেছে, এক্সটার্নাল কোড এর পরিবর্তে restaurant::hosting::add_to_waitlist() পাথ ব্যবহার করতে পারে।

রি-এক্সপোর্টিং তখন উপযোগী যখন আপনার কোডের অভ্যন্তরীণ কাঠামো এবং আপনার কোড কল করা প্রোগ্রামাররা ডোমেইন সম্পর্কে যেভাবে চিন্তা করেন, তা ভিন্ন হয়। উদাহরণস্বরূপ, এই রেস্তোরাঁর রূপকে, রেস্তোরাঁ পরিচালনাকারী ব্যক্তিরা “ফ্রন্ট অফ হাউস” এবং “ব্যাক অফ হাউস” নিয়ে ভাবেন। কিন্তু রেস্তোরাঁয় আসা গ্রাহকরা সম্ভবত রেস্তোরাঁর অংশগুলো সম্পর্কে সেই পরিভাষায় ভাববেন না। pub use-এর মাধ্যমে, আমরা আমাদের কোড একটি কাঠামোতে লিখতে পারি কিন্তু একটি ভিন্ন কাঠামো এক্সপোজ করতে পারি। এটি করলে আমাদের লাইব্রেরিটি লাইব্রেরিতে কাজ করা প্রোগ্রামারদের জন্য এবং লাইব্রেরি কল করা প্রোগ্রামারদের জন্য সুসংগঠিত হয়। আমরা pub use-এর আরেকটি উদাহরণ এবং এটি কীভাবে আপনার ক্রেটের ডকুমেন্টেশনকে প্রভাবিত করে তা অধ্যায় ১৪-এর “pub use দিয়ে একটি সুবিধাজনক পাবলিক API এক্সপোর্ট করা” বিভাগে দেখব।

এক্সটার্নাল প্যাকেজ ব্যবহার করা

দ্বিতীয় অধ্যায়ে, আমরা একটি গেসিং গেম প্রজেক্ট প্রোগ্রাম করেছিলাম যা র‍্যান্ডম নম্বর পেতে rand নামের একটি এক্সটার্নাল প্যাকেজ ব্যবহার করেছিল। আমাদের প্রজেক্টে rand ব্যবহার করার জন্য, আমরা Cargo.toml-এ এই লাইনটি যোগ করেছিলাম:

rand = "0.8.5"

Cargo.toml-এ rand-কে একটি ডিপেন্ডেন্সি হিসাবে যোগ করা কার্গোকে crates.io থেকে rand প্যাকেজ এবং এর যেকোনো ডিপেন্ডেন্সি ডাউনলোড করতে এবং rand আমাদের প্রজেক্টের জন্য উপলব্ধ করতে বলে।

তারপর, rand ডেফিনিশনগুলোকে আমাদের প্যাকেজের স্কোপে আনতে, আমরা ক্রেটের নাম, rand দিয়ে শুরু হওয়া একটি use লাইন যোগ করেছিলাম এবং যে আইটেমগুলো আমরা স্কোপে আনতে চেয়েছিলাম তা তালিকাভুক্ত করেছিলাম। মনে করুন যে দ্বিতীয় অধ্যায়ের “একটি র‍্যান্ডম নম্বর জেনারেট করা” অংশে, আমরা Rng ট্রেইটটিকে স্কোপে নিয়ে এসেছিলাম এবং rand::thread_rng ফাংশনটি কল করেছিলাম:

use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

রাস্ট কমিউনিটির সদস্যরা crates.io-তে অনেক প্যাকেজ উপলব্ধ করেছেন, এবং সেগুলোর যেকোনো একটিকে আপনার প্যাকেজে অন্তর্ভুক্ত করার জন্য এই একই পদক্ষেপগুলো অনুসরণ করতে হয়: সেগুলোকে আপনার প্যাকেজের Cargo.toml ফাইলে তালিকাভুক্ত করা এবং use ব্যবহার করে তাদের ক্রেট থেকে আইটেমগুলোকে স্কোপে আনা।

মনে রাখবেন যে স্ট্যান্ডার্ড std লাইব্রেরিও একটি ক্রেট যা আমাদের প্যাকেজের জন্য এক্সটার্নাল। যেহেতু স্ট্যান্ডার্ড লাইব্রেরিটি রাস্ট ভাষার সাথে সরবরাহ করা হয়, তাই std-কে অন্তর্ভুক্ত করার জন্য আমাদের Cargo.toml পরিবর্তন করার প্রয়োজন নেই। কিন্তু সেখান থেকে আইটেমগুলোকে আমাদের প্যাকেজের স্কোপে আনতে আমাদের use দিয়ে এটিকে রেফার করতে হবে। উদাহরণস্বরূপ, HashMap-এর জন্য আমরা এই লাইনটি ব্যবহার করব:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

এটি একটি অ্যাবসোলিউট পাথ যা std দিয়ে শুরু হয়, যা স্ট্যান্ডার্ড লাইব্রেরি ক্রেটের নাম।

বড় use তালিকা পরিষ্কার করতে নেস্টেড পাথ ব্যবহার করা

যদি আমরা একই ক্রেট বা একই মডিউলে ডিফাইন করা একাধিক আইটেম ব্যবহার করি, তবে প্রতিটি আইটেমকে তার নিজস্ব লাইনে তালিকাভুক্ত করলে আমাদের ফাইলগুলিতে অনেক উল্লম্ব স্থান (vertical space) নষ্ট হতে পারে। উদাহরণস্বরূপ, Listing 2-4-এর গেসিং গেমে আমাদের এই দুটি use স্টেটমেন্ট std থেকে আইটেমগুলোকে স্কোপে এনেছিল:

use rand::Rng;
// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

এর পরিবর্তে, আমরা একই আইটেমগুলোকে এক লাইনে স্কোপে আনতে নেস্টেড পাথ ব্যবহার করতে পারি। আমরা এটি করি পাথের সাধারণ অংশ নির্দিষ্ট করে, তারপরে দুটি কোলন, এবং তারপর কোঁকড়া বন্ধনীর (curly brackets) মধ্যে পাথের বিভিন্ন অংশগুলির একটি তালিকা দিয়ে, যেমনটি Listing 7-18-এ দেখানো হয়েছে।

use rand::Rng;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}```

</Listing>

বড় প্রোগ্রামগুলিতে, নেস্টেড পাথ ব্যবহার করে একই ক্রেট বা মডিউল থেকে অনেক আইটেম স্কোপে আনা পৃথক `use` স্টেটমেন্টের সংখ্যা অনেক কমাতে পারে!

আমরা একটি পাথের যেকোনো স্তরে একটি নেস্টেড পাথ ব্যবহার করতে পারি, যা দুটি `use` স্টেটমেন্টকে একত্রিত করার সময় উপযোগী হয় যেগুলোর একটি সাবপাথ শেয়ার করা থাকে। উদাহরণস্বরূপ, Listing 7-19 দুটি `use` স্টেটমেন্ট দেখায়: একটি যা `std::io`-কে স্কোপে নিয়ে আসে এবং আরেকটি যা `std::io::Write`-কে স্কোপে নিয়ে আসে।

<Listing number="7-19" file-name="src/lib.rs" caption="দুটি `use` স্টেটমেন্ট যেখানে একটি অন্যটির সাবপাথ">

```rust,noplayground
use std::io;
use std::io::Write;

এই দুটি পাথের সাধারণ অংশ হলো std::io, এবং এটিই প্রথম সম্পূর্ণ পাথ। এই দুটি পাথকে একটি use স্টেটমেন্টে একত্রিত করতে, আমরা নেস্টেড পাথে self ব্যবহার করতে পারি, যেমনটি Listing 7-20-এ দেখানো হয়েছে।

use std::io::{self, Write};

এই লাইনটি std::io এবং std::io::Write-কে স্কোপে নিয়ে আসে।

গ্লোব অপারেটর

যদি আমরা একটি পাথে ডিফাইন করা সমস্ত পাবলিক আইটেমকে স্কোপে আনতে চাই, আমরা সেই পাথ এবং তারপরে * গ্লোব অপারেটরটি নির্দিষ্ট করতে পারি:

#![allow(unused)]
fn main() {
use std::collections::*;
}

এই use স্টেটমেন্টটি std::collections-এ ডিফাইন করা সমস্ত পাবলিক আইটেমকে বর্তমান স্কোপে নিয়ে আসে। গ্লোব অপারেটর ব্যবহার করার সময় সতর্ক থাকুন! গ্লোব ব্যবহার করলে কোন নামগুলো স্কোপে আছে এবং আপনার প্রোগ্রামে ব্যবহৃত একটি নাম কোথা থেকে ডিফাইন করা হয়েছে তা বোঝা কঠিন হয়ে যেতে পারে। উপরন্তু, যদি ডিপেন্ডেন্সি তার ডেফিনিশন পরিবর্তন করে, তাহলে আপনি যা ইম্পোর্ট করেছেন তাও পরিবর্তিত হবে, যা ডিপেন্ডেন্সি আপগ্রেড করার সময় কম্পাইলার এররের কারণ হতে পারে, যদি ডিপেন্ডেন্সি আপনার একই স্কোপের কোনো ডেফিনিশনের মতো একই নামের একটি ডেফিনিশন যোগ করে, উদাহরণস্বরূপ।

গ্লোব অপারেটরটি প্রায়শই টেস্টিংয়ের সময় tests মডিউলের মধ্যে পরীক্ষার অধীনে থাকা সমস্ত কিছু আনতে ব্যবহৃত হয়; আমরা এটি সম্পর্কে অধ্যায় ১১-এর “কিভাবে টেস্ট লিখতে হয়” অংশে কথা বলব। গ্লোব অপারেটরটি কখনও কখনও প্রিলিউড প্যাটার্নের অংশ হিসাবেও ব্যবহৃত হয়: সেই প্যাটার্ন সম্পর্কে আরও তথ্যের জন্য স্ট্যান্ডার্ড লাইব্রেরির ডকুমেন্টেশন দেখুন।

মডিউলগুলোকে বিভিন্ন ফাইলে বিভক্ত করা

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

উদাহরণস্বরূপ, চলুন Listing 7-17-এর কোড থেকে শুরু করি যেখানে একাধিক রেস্তোরাঁ মডিউল ছিল। আমরা সব মডিউল ক্রেট রুট ফাইলে ডিফাইন না করে, মডিউলগুলোকে আলাদা ফাইলে এক্সট্র্যাক্ট করব। এই ক্ষেত্রে, ক্রেট রুট ফাইলটি হলো src/lib.rs, কিন্তু এই পদ্ধতিটি বাইনারি ক্রেটের ক্ষেত্রেও কাজ করে যার ক্রেট রুট ফাইল হলো src/main.rs।

প্রথমে আমরা front_of_house মডিউলটিকে তার নিজস্ব ফাইলে এক্সট্র্যাক্ট করব। front_of_house মডিউলের জন্য কোঁকড়া বন্ধনীর (curly brackets) ভিতরের কোডটি সরিয়ে ফেলুন, শুধুমাত্র mod front_of_house; ডিক্লেয়ারেশনটি রেখে দিন, যাতে src/lib.rs ফাইলে Listing 7-21-এ দেখানো কোডটি থাকে। মনে রাখবেন, যতক্ষণ না আমরা Listing 7-22-এ src/front_of_house.rs ফাইলটি তৈরি করছি, ততক্ষণ এটি কম্পাইল হবে না।

mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

এরপর, কোঁকড়া বন্ধনীর মধ্যে যে কোডটি ছিল, সেটি src/front_of_house.rs নামের একটি নতুন ফাইলে রাখুন, যেমনটি Listing 7-22-এ দেখানো হয়েছে। কম্পাইলার জানে যে এই ফাইলটিতে কোড খুঁজতে হবে কারণ এটি ক্রেট রুটে front_of_house নামের মডিউল ডিক্লেয়ারেশনটি পেয়েছে।

pub mod hosting {
    pub fn add_to_waitlist() {}
}```

</Listing>

মনে রাখবেন যে আপনার মডিউল ট্রি-তে একটি `mod` ডিক্লেয়ারেশন ব্যবহার করে একটি ফাইল শুধুমাত্র _একবারই_ লোড করতে হবে। একবার কম্পাইলার জেনে গেলে যে ফাইলটি প্রজেক্টের অংশ (এবং `mod` স্টেটমেন্টটি কোথায় রেখেছেন তার উপর ভিত্তি করে মডিউল ট্রি-তে কোডটি কোথায় অবস্থিত তা জানে), আপনার প্রজেক্টের অন্যান্য ফাইলগুলোকে লোড করা ফাইলের কোডটি তার ডিক্লেয়ার করা পাথ ব্যবহার করে রেফার করা উচিত, যা [“মডিউল ট্রি-তে কোনো আইটেম রেফার করার জন্য পাথ”][paths]<!-- ignore --> বিভাগে আলোচনা করা হয়েছে। অন্য কথায়, `mod` একটি “include” অপারেশন _নয়_ যা আপনি অন্যান্য প্রোগ্রামিং ভাষায় দেখে থাকতে পারেন।

এর পরে, আমরা `hosting` মডিউলটিকে তার নিজস্ব ফাইলে এক্সট্র্যাক্ট করব। প্রক্রিয়াটি কিছুটা ভিন্ন কারণ `hosting` হলো `front_of_house`-এর একটি চাইল্ড মডিউল, রুট মডিউলের নয়। আমরা `hosting`-এর জন্য ফাইলটিকে একটি নতুন ডিরেক্টরিতে রাখব যার নাম হবে মডিউল ট্রি-তে তার পূর্বপুরুষদের নামে, এই ক্ষেত্রে _src/front_of_house_।

`hosting` সরানো শুরু করতে, আমরা _src/front_of_house.rs_ পরিবর্তন করে শুধুমাত্র `hosting` মডিউলের ডিক্লেয়ারেশনটি রাখব:

<Listing file-name="src/front_of_house.rs">

```rust,ignore
pub mod hosting;

তারপর আমরা একটি src/front_of_house ডিরেক্টরি এবং একটি hosting.rs ফাইল তৈরি করব যাতে hosting মডিউলে করা ডেফিনিশনগুলো থাকবে:

pub fn add_to_waitlist() {}

যদি আমরা এর পরিবর্তে hosting.rs ফাইলটি src ডিরেক্টরিতে রাখতাম, কম্পাইলার আশা করত যে hosting.rs কোডটি ক্রেট রুটে ডিক্লেয়ার করা একটি hosting মডিউলে থাকবে, এবং front_of_house মডিউলের চাইল্ড হিসাবে ডিক্লেয়ার করা হবে না। কোন মডিউলের কোডের জন্য কোন ফাইলগুলো পরীক্ষা করতে হবে সে সম্পর্কে কম্পাইলারের নিয়মগুলোর মানে হলো ডিরেক্টরি এবং ফাইলগুলো মডিউল ট্রি-এর সাথে আরও ঘনিষ্ঠভাবে মিলে যায়।

বিকল্প ফাইল পাথ

এখন পর্যন্ত আমরা সবচেয়ে প্রচলিত ফাইল পাথগুলো কভার করেছি যা রাস্ট কম্পাইলার ব্যবহার করে, কিন্তু রাস্ট একটি পুরানো স্টাইলের ফাইল পাথও সাপোর্ট করে। ক্রেট রুটে ডিক্লেয়ার করা front_of_house নামের একটি মডিউলের জন্য, কম্পাইলার মডিউলের কোডটি খুঁজবে:

• src/front_of_house.rs (যা আমরা কভার করেছি)
• src/front_of_house/mod.rs (পুরানো স্টাইল, এখনও সমর্থিত পাথ)

front_of_house-এর একটি সাবমডিউল hosting-এর জন্য, কম্পাইলার মডিউলের কোড খুঁজবে:

• src/front_of_house/hosting.rs (যা আমরা কভার করেছি)
• src/front_of_house/hosting/mod.rs (পুরানো স্টাইল, এখনও সমর্থিত পাথ)

আপনি যদি একই মডিউলের জন্য উভয় স্টাইল ব্যবহার করেন, আপনি একটি কম্পাইলার এরর পাবেন। একই প্রজেক্টে বিভিন্ন মডিউলের জন্য উভয় স্টাইলের মিশ্রণ ব্যবহার করা অনুমোদিত, কিন্তু এটি আপনার প্রজেক্ট নেভিগেট করা লোকেদের জন্য বিভ্রান্তিকর হতে পারে।

mod.rs নামের ফাইল ব্যবহার করার স্টাইলের প্রধান অসুবিধা হলো আপনার প্রজেক্টে অনেকগুলো mod.rs নামের ফাইল তৈরি হতে পারে, যা আপনার এডিটরে একই সময়ে খোলা থাকলে বিভ্রান্তিকর হতে পারে।

আমরা প্রতিটি মডিউলের কোড একটি পৃথক ফাইলে সরিয়েছি, এবং মডিউল ট্রি একই রয়েছে। eat_at_restaurant-এর ফাংশন কলগুলো কোনো পরিবর্তন ছাড়াই কাজ করবে, যদিও ডেফিনিশনগুলো বিভিন্ন ফাইলে রয়েছে। এই কৌশলটি আপনাকে মডিউলগুলো আকারে বড় হওয়ার সাথে সাথে নতুন ফাইলে স্থানান্তর করতে দেয়।

মনে রাখবেন যে src/lib.rs-এর pub use crate::front_of_house::hosting স্টেটমেন্টটিও পরিবর্তিত হয়নি, এবং use-এর ক্রেটের অংশ হিসাবে কোন ফাইলগুলো কম্পাইল করা হয় তার উপর কোনো প্রভাব নেই। mod কীওয়ার্ড মডিউল ডিক্লেয়ার করে, এবং রাস্ট সেই মডিউলে থাকা কোডের জন্য মডিউলের নামের সাথে মিলিয়ে একটি ফাইল খোঁজে।

সারসংক্ষেপ

রাস্ট আপনাকে একটি প্যাকেজকে একাধিক ক্রেটে এবং একটি ক্রেটকে একাধিক মডিউলে বিভক্ত করতে দেয় যাতে আপনি এক মডিউলে ডিফাইন করা আইটেম অন্য মডিউল থেকে রেফার করতে পারেন। আপনি অ্যাবসোলিউট বা রিলেটিভ পাথ নির্দিষ্ট করে এটি করতে পারেন। এই পাথগুলো একটি use স্টেটমেন্টের মাধ্যমে স্কোপে আনা যেতে পারে যাতে আপনি সেই স্কোপে আইটেমটির একাধিক ব্যবহারের জন্য একটি ছোট পাথ ব্যবহার করতে পারেন। মডিউল কোড ডিফল্টরূপে প্রাইভেট থাকে, কিন্তু আপনি pub কীওয়ার্ড যোগ করে ডেফিনিশনগুলোকে পাবলিক করতে পারেন।

পরবর্তী অধ্যায়ে, আমরা স্ট্যান্ডার্ড লাইব্রেরির কিছু কালেকশন ডেটা স্ট্রাকচার দেখব যা আপনি আপনার সুন্দরভাবে সাজানো কোডে ব্যবহার করতে পারবেন।

সাধারণ Collections

Rust-এর standard library-তে খুবই দরকারি কিছু ডেটা স্ট্রাকচার (data structure) রয়েছে, যেগুলোকে collections বলা হয়। বেশিরভাগ ডেটা টাইপ (data type) একটি নির্দিষ্ট ভ্যালু (value) প্রকাশ করে, কিন্তু collections-এ একাধিক ভ্যালু থাকতে পারে। বিল্ট-ইন (built-in) array এবং tuple টাইপের মতো নয়, এই collections-এর ডেটা heap-এ স্টোর করা হয়। এর মানে হলো, compile time-এ ডেটার পরিমাণ জানার প্রয়োজন হয় না এবং প্রোগ্রাম (program) চলার সময় এটি বাড়তে বা কমতে পারে। প্রতিটি collection-এর নিজস্ব সক্ষমতা এবং সীমাবদ্ধতা রয়েছে। আপনার প্রয়োজন অনুযায়ী সঠিক collection বেছে নেওয়া একটি দক্ষতা যা সময়ের সাথে সাথে আপনি অর্জন করবেন। এই অধ্যায়ে আমরা তিনটি বহুল ব্যবহৃত collection নিয়ে আলোচনা করব:

• একটি vector আপনাকে একাধিক ভ্যালু একে অপরের পাশে রেখে স্টোর করার সুযোগ দেয়।
• একটি string হলো ক্যারেক্টার বা অক্ষরের একটি collection। আমরা এর আগে String টাইপ নিয়ে কথা বলেছি, কিন্তু এই অধ্যায়ে আমরা এটি নিয়ে বিস্তারিত আলোচনা করব।
• একটি hash map আপনাকে একটি নির্দিষ্ট key-এর সাথে একটি ভ্যালু যুক্ত করার সুযোগ দেয়। এটি map নামক সাধারণ ডেটা স্ট্রাকচারের একটি বিশেষ বাস্তবায়ন।

Standard library-র অন্যান্য collection সম্পর্কে জানতে the documentation দেখুন।

আমরা এই অধ্যায়ে vector, string, এবং hash map কীভাবে তৈরি ও আপডেট করতে হয় এবং এদের প্রত্যেকের বিশেষত্ব কী, তা নিয়ে আলোচনা করব।

Vector ব্যবহার করে ভ্যালুর তালিকা স্টোর করা

আমরা প্রথম যে collection টাইপটি দেখব তা হলো Vec<T>, যা vector নামেও পরিচিত। Vector আপনাকে একটি ডেটা স্ট্রাকচারের মধ্যে একাধিক ভ্যালু স্টোর করার সুযোগ দেয়, যা মেমরিতে সমস্ত ভ্যালু একে অপরের পাশে রাখে। Vector শুধুমাত্র একই টাইপের ভ্যালু স্টোর করতে পারে। যখন আপনার কাছে আইটেমের একটি তালিকা থাকে, যেমন একটি ফাইলের টেক্সট লাইন বা শপিং কার্টে থাকা আইটেমের দাম, তখন এগুলি খুব দরকারি।

নতুন Vector তৈরি করা

একটি নতুন খালি vector তৈরি করতে, আমরা Vec::new ফাংশনটি কল করি, যেমনটি লিস্টিং ৮-১ এ দেখানো হয়েছে।

fn main() {
    let v: Vec<i32> = Vec::new();
}

লক্ষ্য করুন, আমরা এখানে একটি type annotation যোগ করেছি। যেহেতু আমরা এই vector-এ কোনো ভ্যালু রাখছি না, তাই Rust জানে না আমরা কী ধরনের element স্টোর করতে চাই। এটি একটি গুরুত্বপূর্ণ বিষয়। Vector জেনেরিক (generics) ব্যবহার করে তৈরি করা হয়; আমরা অধ্যায় ১০-এ আপনার নিজের টাইপের সাথে জেনেরিক কীভাবে ব্যবহার করতে হয় তা আলোচনা করব। আপাতত জেনে রাখুন যে standard library দ্বারা সরবরাহ করা Vec<T> টাইপটি যেকোনো টাইপ ধারণ করতে পারে। যখন আমরা একটি নির্দিষ্ট টাইপের ভ্যালু রাখার জন্য একটি vector তৈরি করি, তখন আমরা angle brackets-এর মধ্যে টাইপটি নির্দিষ্ট করতে পারি। লিস্টিং ৮-১ এ, আমরা Rust-কে বলেছি যে v-তে থাকা Vec<T> টি i32 টাইপের element ধারণ করবে।

বেশিরভাগ সময়, আপনি প্রাথমিক ভ্যালুসহ একটি Vec<T> তৈরি করবেন এবং Rust অনুমান করে নেবে আপনি কোন টাইপের ভ্যালু স্টোর করতে চান, তাই আপনাকে খুব কমই এই type annotation করতে হবে। Rust সুবিধাজনকভাবে vec! macro সরবরাহ করে, যা আপনার দেওয়া ভ্যালুগুলো ধারণ করে একটি নতুন vector তৈরি করবে। লিস্টিং ৮-২ একটি নতুন Vec<i32> তৈরি করে যা 1, 2, এবং 3 ভ্যালুগুলো ধারণ করে। Integer টাইপটি i32 কারণ এটি ডিফল্ট ইন্টিজার টাইপ, যা আমরা অধ্যায় ৩ এর "Data Types" বিভাগে আলোচনা করেছি।

fn main() {
    let v = vec![1, 2, 3];
}

যেহেতু আমরা প্রাথমিক i32 ভ্যালু দিয়েছি, Rust অনুমান করতে পারে যে v-এর টাইপ হলো Vec<i32>, এবং type annotation-এর প্রয়োজন নেই। এরপর, আমরা দেখব কীভাবে একটি vector পরিবর্তন করতে হয়।

Vector আপডেট করা

একটি vector তৈরি করে তাতে element যোগ করার জন্য, আমরা push মেথড ব্যবহার করতে পারি, যেমনটি লিস্টিং ৮-৩ এ দেখানো হয়েছে।

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

যেকোনো ভ্যারিয়েবলের মতোই, যদি আমরা এর ভ্যালু পরিবর্তন করতে চাই, তবে অধ্যায় ৩-এ আলোচিত mut কীওয়ার্ড ব্যবহার করে এটিকে mutable করতে হবে। আমরা যে সংখ্যাগুলো এর ভেতরে রেখেছি তা সবই i32 টাইপের, এবং Rust ডেটা থেকে এটি অনুমান করে নেয়, তাই আমাদের Vec<i32> annotation-এর প্রয়োজন নেই।

Vector-এর Element পড়া

একটি vector-এ স্টোর করা ভ্যালু রেফারেন্স করার দুটি উপায় আছে: indexing ব্যবহার করে অথবা get মেথড ব্যবহার করে। নীচের উদাহরণগুলিতে, আমরা অতিরিক্ত স্পষ্টতার জন্য এই ফাংশনগুলো থেকে ফেরত আসা ভ্যালুগুলির টাইপ annotate করেছি।

লিস্টিং ৮-৪ একটি vector-এর ভ্যালু অ্যাক্সেস করার উভয় পদ্ধতি দেখায়, indexing সিনট্যাক্স এবং get মেথডসহ।

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let third: &i32 = &v[2];
    println!("The third element is {third}");

    let third: Option<&i32> = v.get(2);
    match third {
        Some(third) => println!("The third element is {third}"),
        None => println!("There is no third element."),
    }
}

এখানে কয়েকটি বিষয় লক্ষ্য করুন। আমরা তৃতীয় element পেতে index ভ্যালু 2 ব্যবহার করি কারণ vector শূন্য থেকে সংখ্যা দ্বারা index করা হয়। & এবং [] ব্যবহার করে আমরা index-এর element-এর একটি রেফারেন্স পাই। যখন আমরা get মেথডটি আর্গুমেন্ট হিসাবে index পাস করে ব্যবহার করি, তখন আমরা একটি Option<&T> পাই যা আমরা match-এর সাথে ব্যবহার করতে পারি।

Rust একটি element রেফারেন্স করার এই দুটি উপায় সরবরাহ করে যাতে আপনি বেছে নিতে পারেন যে প্রোগ্রামটি কীভাবে আচরণ করবে যখন আপনি বিদ্যমান element-এর পরিসরের বাইরের কোনো index ভ্যালু ব্যবহার করার চেষ্টা করবেন। উদাহরণস্বরূপ, ধরা যাক আমাদের পাঁচটি element-এর একটি vector আছে এবং আমরা প্রতিটি কৌশল ব্যবহার করে ১০০তম index-এর একটি element অ্যাক্সেস করার চেষ্টা করি, যেমনটি লিস্টিং ৮-৫ এ দেখানো হয়েছে।

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let does_not_exist = &v[100];
    let does_not_exist = v.get(100);
}```

</Listing>

যখন আমরা এই কোডটি চালাই, প্রথম `[]` মেথডটি প্রোগ্রামটিকে প্যানিক (panic) করাবে কারণ এটি একটি অস্তিত্বহীন element-কে রেফারেন্স করছে। এই পদ্ধতিটি তখনই সবচেয়ে ভালো যখন আপনি চান যে আপনার প্রোগ্রামটি ক্র্যাশ করুক যদি vector-এর শেষের বাইরে কোনো element অ্যাক্সেস করার চেষ্টা করা হয়।

যখন `get` মেথডটিকে এমন একটি index পাস করা হয় যা vector-এর বাইরে, তখন এটি প্যানিক না করে `None` রিটার্ন করে। আপনি এই পদ্ধতিটি ব্যবহার করবেন যদি vector-এর পরিসরের বাইরের কোনো element অ্যাক্সেস করা সাধারণ পরিস্থিতিতে মাঝে মাঝে ঘটতে পারে। আপনার কোডে তখন `Some(&element)` বা `None` পরিচালনা করার জন্য লজিক থাকবে, যেমনটি অধ্যায় ৬-এ আলোচনা করা হয়েছে। উদাহরণস্বরূপ, indexটি কোনো ব্যক্তি দ্বারা একটি সংখ্যা ইনপুট করার মাধ্যমে আসতে পারে। যদি তারা ভুলবশত একটি খুব বড় সংখ্যা প্রবেশ করায় এবং প্রোগ্রামটি একটি `None` ভ্যালু পায়, আপনি ব্যবহারকারীকে বলতে পারেন বর্তমান vector-এ কতগুলি আইটেম আছে এবং তাদের একটি বৈধ ভ্যালু প্রবেশ করার আরেকটি সুযোগ দিতে পারেন। এটি একটি টাইপের ভুলের জন্য প্রোগ্রাম ক্র্যাশ করার চেয়ে বেশি ব্যবহারকারী-বান্ধব হবে!

যখন প্রোগ্রামের একটি বৈধ রেফারেন্স থাকে, তখন borrow checker মালিকানা এবং ধার করার নিয়মগুলি (অধ্যায় ৪-এ আচ্ছাদিত) প্রয়োগ করে যাতে এই রেফারেন্স এবং vector-এর বিষয়বস্তুর অন্য কোনো রেফারেন্স বৈধ থাকে। সেই নিয়মটি স্মরণ করুন যা বলে যে আপনি একই স্কোপে mutable এবং immutable রেফারেন্স রাখতে পারবেন না। সেই নিয়মটি লিস্টিং ৮-৬-এ প্রযোজ্য, যেখানে আমরা একটি vector-এর প্রথম element-এর একটি immutable রেফারেন্স ধরে রাখি এবং শেষে একটি element যোগ করার চেষ্টা করি। এই প্রোগ্রামটি কাজ করবে না যদি আমরা ফাংশনের পরে সেই element-কে আবার রেফারেন্স করার চেষ্টা করি।

<Listing number="8-6" caption="একটি আইটেমের রেফারেন্স ধরে রেখে একটি vector-এ একটি element যোগ করার চেষ্টা">

```rust,ignore,does_not_compile
fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let first = &v[0];

    v.push(6);

    println!("The first element is: {first}");
}

এই কোডটি কম্পাইল করলে এই error-টি আসবে:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:5
  |
4 |     let first = &v[0];
  |                  - immutable borrow occurs here
5 |
6 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
7 |
8 |     println!("The first element is: {first}");
  |                                     ------- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` (bin "collections") due to 1 previous error

লিস্টিং ৮-৬ এর কোডটি দেখে মনে হতে পারে যে এটি কাজ করা উচিত: প্রথম element-এর একটি রেফারেন্স vector-এর শেষের পরিবর্তনে কেন পাত্তা দেবে? এই error-টি vector-এর কাজ করার পদ্ধতির কারণে হয়: কারণ vector মেমরিতে ভ্যালুগুলো একে অপরের পাশে রাখে, vector-এর শেষে একটি নতুন element যোগ করার জন্য নতুন মেমরি বরাদ্দ করার এবং পুরানো element-গুলো নতুন জায়গায় অনুলিপি করার প্রয়োজন হতে পারে, যদি vector-টি যেখানে বর্তমানে সংরক্ষিত আছে সেখানে সমস্ত element পাশাপাশি রাখার জন্য পর্যাপ্ত জায়গা না থাকে। সেক্ষেত্রে, প্রথম element-এর রেফারেন্সটি একটি ডিঅ্যালোকেটেড মেমরির দিকে নির্দেশ করবে। ধার করার নিয়মগুলি প্রোগ্রামগুলিকে সেই পরিস্থিতিতে পড়া থেকে বিরত রাখে।

দ্রষ্টব্য: Vec<T> টাইপের বাস্তবায়নের বিবরণ সম্পর্কে আরও জানতে, "The Rustonomicon" দেখুন।

Vector-এর ভ্যালুগুলোর উপর Iterate করা

একটি vector-এর প্রতিটি element-কে পর্যায়ক্রমে অ্যাক্সেস করার জন্য, আমরা একবারে একটি অ্যাক্সেস করার জন্য index ব্যবহার না করে সমস্ত element-এর মধ্যে দিয়ে iterate করব। লিস্টিং ৮-৭ দেখায় কীভাবে একটি for লুপ ব্যবহার করে i32 ভ্যালুর একটি vector-এর প্রতিটি element-এর immutable রেফারেন্স পেতে এবং সেগুলি প্রিন্ট করতে হয়।

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{i}");
    }
}

আমরা সমস্ত element-এ পরিবর্তন আনার জন্য একটি mutable vector-এর প্রতিটি element-এর mutable রেফারেন্সের উপরও iterate করতে পারি। লিস্টিং ৮-৮ এর for লুপ প্রতিটি element-এর সাথে 50 যোগ করবে।

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

mutable রেফারেন্স যে ভ্যালুকে নির্দেশ করে তা পরিবর্তন করতে, আমাদের * dereference operator ব্যবহার করতে হবে i-এর ভ্যালুটি পাওয়ার জন্য, তারপর আমরা += operator ব্যবহার করতে পারি। আমরা dereference operator সম্পর্কে অধ্যায় ১৫-এর "Following the Reference to the Value" বিভাগে আরও কথা বলব।

একটি vector-এর উপর iterate করা, immutable হোক বা mutable, borrow checker-এর নিয়মের কারণে নিরাপদ। যদি আমরা লিস্টিং ৮-৭ এবং লিস্টিং ৮-৮ এর for লুপের বডিতে আইটেম ঢোকানো বা সরানোর চেষ্টা করতাম, আমরা লিস্টিং ৮-৬ এর কোডের মতো একটি compiler error পেতাম। for লুপ যে vector-এর রেফারেন্স ধরে রাখে তা পুরো vector-এর একযোগে পরিবর্তন প্রতিরোধ করে।

একাধিক Type স্টোর করার জন্য Enum ব্যবহার

Vector শুধুমাত্র একই টাইপের ভ্যালু স্টোর করতে পারে। এটি অসুবিধাজনক হতে পারে; বিভিন্ন টাইপের আইটেমের তালিকা স্টোর করার প্রয়োজন অবশ্যই আছে। সৌভাগ্যবশত, একটি enum-এর ভ্যারিয়েন্টগুলি একই enum টাইপের অধীনে সংজ্ঞায়িত করা হয়, তাই যখন আমাদের বিভিন্ন টাইপের element প্রতিনিধিত্ব করার জন্য একটি টাইপের প্রয়োজন হয়, তখন আমরা একটি enum সংজ্ঞায়িত এবং ব্যবহার করতে পারি!

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

fn main() {
    enum SpreadsheetCell {
        Int(i32),
        Float(f64),
        Text(String),
    }

    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];
}

Rust-কে compile time-এ জানতে হবে vector-এ কোন টাইপগুলো থাকবে যাতে এটি জানতে পারে প্রতিটি element স্টোর করার জন্য heap-এ ঠিক কতটা মেমরি লাগবে। এই vector-এ কোন টাইপগুলো অনুমোদিত সে সম্পর্কেও আমাদের সুস্পষ্ট হতে হবে। যদি Rust একটি vector-কে যেকোনো টাইপ ধারণ করার অনুমতি দিত, তাহলে একটি বা একাধিক টাইপ vector-এর element-গুলোর উপর সঞ্চালিত অপারেশনগুলির সাথে error ঘটাতে পারত। একটি enum এবং একটি match এক্সপ্রেশন ব্যবহার করার অর্থ হল যে Rust compile time-এ নিশ্চিত করবে যে প্রতিটি সম্ভাব্য কেস পরিচালনা করা হয়েছে, যেমনটি অধ্যায় ৬-এ আলোচনা করা হয়েছে।

যদি আপনি না জানেন যে একটি প্রোগ্রাম রানটাইমে একটি vector-এ স্টোর করার জন্য কোন কোন টাইপ পাবে, তাহলে enum কৌশলটি কাজ করবে না। এর পরিবর্তে, আপনি একটি trait object ব্যবহার করতে পারেন, যা আমরা অধ্যায় ১৮-এ আলোচনা করব।

এখন যেহেতু আমরা vector ব্যবহারের কিছু সবচেয়ে সাধারণ উপায় নিয়ে আলোচনা করেছি, standard library দ্বারা Vec<T>-তে সংজ্ঞায়িত সমস্ত দরকারি মেথডগুলির জন্য the API documentation পর্যালোচনা করতে ভুলবেন না। উদাহরণস্বরূপ, push ছাড়াও, একটি pop মেথড রয়েছে যা শেষ element-টি সরিয়ে দেয় এবং ফেরত দেয়।

Vector Drop হলে তার Element-গুলোও Drop হয়

অন্য যেকোনো struct-এর মতো, একটি vector যখন স্কোপের বাইরে চলে যায় তখন তা মুক্ত হয়ে যায়, যেমনটি লিস্টিং ৮-১০-এ দেখানো হয়েছে।

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // do stuff with v
    } // <- v goes out of scope and is freed here
}

যখন vector-টি ড্রপ করা হয়, তখন তার সমস্ত বিষয়বস্তুও ড্রপ করা হয়, যার মানে হল এটি যে ইন্টিজারগুলি ধারণ করে সেগুলি পরিষ্কার করা হবে। borrow checker নিশ্চিত করে যে একটি vector-এর বিষয়বস্তুর যেকোনো রেফারেন্স শুধুমাত্র তখনই ব্যবহৃত হয় যখন vector নিজেই বৈধ থাকে।

চলুন পরবর্তী collection টাইপ-এ যাওয়া যাক: String!

স্ট্রিং ব্যবহার করে UTF-8 এনকোডেড টেক্সট স্টোর করা

আমরা অধ্যায় ৪-এ স্ট্রিং নিয়ে আলোচনা করেছি, কিন্তু এখন আমরা এটি আরও গভীরভাবে দেখব। নতুন Rust ব্যবহারকারীরা সাধারণত তিনটি কারণে স্ট্রিং নিয়ে সমস্যায় পড়েন: সম্ভাব্য error তুলে ধরার ক্ষেত্রে Rust-এর প্রবণতা, স্ট্রিং ডেটা স্ট্রাকচারটি যতটা সহজ ভাবা হয় তার চেয়ে বেশি জটিল হওয়া, এবং UTF-8। এই কারণগুলো একত্রিত হয়ে এমন পরিস্থিতি তৈরি করে যা অন্যান্য প্রোগ্রামিং ল্যাঙ্গুয়েজ থেকে আসা ডেভেলপারদের জন্য কঠিন মনে হতে পারে।

আমরা collections-এর প্রেক্ষাপটে স্ট্রিং নিয়ে আলোচনা করছি কারণ স্ট্রিং মূলত বাইটের (bytes) একটি collection হিসাবে প্রয়োগ করা হয়, এবং এর সাথে কিছু অতিরিক্ত মেথড থাকে যা সেই বাইটগুলোকে টেক্সট হিসাবে ব্যাখ্যা করার সময় দরকারি কার্যকারিতা প্রদান করে। এই বিভাগে, আমরা String-এর সেইসব অপারেশন নিয়ে কথা বলব যা প্রতিটি collection টাইপের মধ্যেই রয়েছে, যেমন তৈরি করা, আপডেট করা এবং পড়া। এছাড়াও আমরা আলোচনা করব String অন্যান্য collection থেকে কোন কোন ক্ষেত্রে আলাদা, বিশেষ করে মানুষ এবং কম্পিউটার যেভাবে String ডেটাকে ব্যাখ্যা করে তার পার্থক্যের কারণে String-এ ইনডেক্সিং (indexing) করাটা বেশ জটিল।

স্ট্রিং কী?

প্রথমে আমরা স্ট্রিং বলতে কী বুঝি তা নির্ধারণ করব। Rust-এর কোর ল্যাঙ্গুয়েজে শুধুমাত্র একটি স্ট্রিং টাইপ আছে, যা হলো স্ট্রিং স্লাইস str, এবং এটি সাধারণত এর ধার করা (borrowed) রূপ &str-এ দেখা যায়। অধ্যায় ৪-এ, আমরা স্ট্রিং স্লাইস নিয়ে কথা বলেছিলাম, যা অন্য কোথাও স্টোর করা UTF-8 এনকোডেড স্ট্রিং ডেটার রেফারেন্স। উদাহরণস্বরূপ, স্ট্রিং লিটারেল (string literals) প্রোগ্রামের বাইনারিতে স্টোর করা হয় এবং তাই সেগুলি স্ট্রিং স্লাইস।

String টাইপটি Rust-এর standard library দ্বারা সরবরাহ করা হয়, এটি কোর ল্যাঙ্গুয়েজে কোড করা নেই। এটি একটি পরিবর্তনশীল (growable), পরিবর্তনযোগ্য (mutable), নিজস্ব (owned), এবং UTF-8 এনকোডেড স্ট্রিং টাইপ। যখন Rust ব্যবহারকারীরা "স্ট্রিং" বলেন, তখন তারা String বা স্ট্রিং স্লাইস &str উভয়কেই বোঝাতে পারেন, শুধু একটিকে নয়। যদিও এই বিভাগটি মূলত String সম্পর্কিত, উভয় টাইপই Rust-এর standard library-তে ব্যাপকভাবে ব্যবহৃত হয় এবং String ও স্ট্রিং স্লাইস উভয়ই UTF-8 এনকোডেড।

নতুন স্ট্রিং তৈরি করা

Vec<T>-এর সাথে উপলব্ধ অনেক অপারেশন String-এর সাথেও উপলব্ধ, কারণ String আসলে বাইটের একটি vector-এর উপর একটি র‍্যাপার (wrapper) হিসাবে প্রয়োগ করা হয়েছে, যাতে কিছু অতিরিক্ত গ্যারান্টি, সীমাবদ্ধতা এবং ক্ষমতা রয়েছে। Vec<T> এবং String-এর সাথে একইভাবে কাজ করে এমন একটি ফাংশনের উদাহরণ হলো new ফাংশন, যা একটি ইনস্ট্যান্স তৈরি করতে ব্যবহৃত হয়, যেমনটি লিস্টিং ৮-১১-তে দেখানো হয়েছে।

fn main() {
    let mut s = String::new();
}

এই লাইনটি s নামে একটি নতুন, খালি স্ট্রিং তৈরি করে, যেখানে আমরা পরে ডেটা লোড করতে পারব। প্রায়শই, আমাদের কাছে কিছু প্রাথমিক ডেটা থাকে যা দিয়ে আমরা স্ট্রিং শুরু করতে চাই। এর জন্য, আমরা to_string মেথড ব্যবহার করি, যা Display trait প্রয়োগকারী যেকোনো টাইপের উপর উপলব্ধ, যেমন স্ট্রিং লিটারেল। লিস্টিং ৮-১২ দুটি উদাহরণ দেখায়।

fn main() {
    let data = "initial contents";

    let s = data.to_string();

    // The method also works on a literal directly:
    let s = "initial contents".to_string();
}

এই কোডটি initial contents লেখা সহ একটি স্ট্রিং তৈরি করে।

আমরা String::from ফাংশন ব্যবহার করেও একটি স্ট্রিং লিটারেল থেকে String তৈরি করতে পারি। লিস্টিং ৮-১৩-এর কোডটি লিস্টিং ৮-১২-এর কোডের সমতুল্য যা to_string ব্যবহার করে।

fn main() {
    let s = String::from("initial contents");
}

যেহেতু স্ট্রিং অনেক কিছুর জন্য ব্যবহৃত হয়, আমরা স্ট্রিং-এর জন্য বিভিন্ন জেনেরিক API ব্যবহার করতে পারি, যা আমাদের অনেক বিকল্প সরবরাহ করে। তাদের মধ্যে কিছু অপ্রয়োজনীয় মনে হতে পারে, কিন্তু সবগুলোরই নিজস্ব স্থান আছে! এক্ষেত্রে, String::from এবং to_string একই কাজ করে, তাই আপনি কোনটি বেছে নেবেন তা আপনার স্টাইল এবং পঠনযোগ্যতার উপর নির্ভর করে।

মনে রাখবেন যে স্ট্রিংগুলো UTF-8 এনকোডেড, তাই আমরা সেগুলিতে যেকোনো সঠিকভাবে এনকোড করা ডেটা অন্তর্ভুক্ত করতে পারি, যেমনটি লিস্টিং ৮-১৪-তে দেখানো হয়েছে।

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

এগুলো সবই বৈধ String ভ্যালু।

একটি স্ট্রিং আপডেট করা

একটি String-এর আকার বাড়তে পারে এবং এর বিষয়বস্তু পরিবর্তন হতে পারে, যেমন Vec<T>-এর বিষয়বস্তু পরিবর্তন করা যায়, যদি আপনি এতে আরও ডেটা পুশ করেন। এছাড়াও, আপনি সুবিধামত + অপারেটর বা format! ম্যাক্রো ব্যবহার করে String ভ্যালু সংযুক্ত (concatenate) করতে পারেন।

push_str এবং push দিয়ে একটি স্ট্রিং-এ যোগ করা

আমরা push_str মেথড ব্যবহার করে একটি স্ট্রিং স্লাইস যোগ করে একটি String বড় করতে পারি, যেমনটি লিস্টিং ৮-১৫-তে দেখানো হয়েছে।

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

এই দুটি লাইনের পরে, s-এ foobar থাকবে। push_str মেথডটি একটি স্ট্রিং স্লাইস নেয় কারণ আমরা প্যারামিটারের মালিকানা (ownership) নিতে চাই না। উদাহরণস্বরূপ, লিস্টিং ৮-১৬-এর কোডে, আমরা s1-এ s2-এর বিষয়বস্তু যোগ করার পরেও s2 ব্যবহার করতে চাই।

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {s2}");
}

যদি push_str মেথডটি s2-এর মালিকানা নিয়ে নিত, আমরা শেষ লাইনে এর ভ্যালু প্রিন্ট করতে পারতাম না। কিন্তু এই কোডটি আমাদের প্রত্যাশা অনুযায়ী কাজ করে!

push মেথডটি একটি একক ক্যারেক্টার (character) প্যারামিটার হিসাবে নেয় এবং এটি String-এ যোগ করে। লিস্টিং ৮-১৭ push মেথড ব্যবহার করে একটি String-এ l অক্ষরটি যোগ করে।

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

এর ফলে, s-এ lol থাকবে।

+ অপারেটর বা format! ম্যাক্রো দিয়ে Concatenation

প্রায়শই, আপনি দুটি বিদ্যমান স্ট্রিং একত্রিত করতে চাইবেন। একটি উপায় হলো + অপারেটর ব্যবহার করা, যেমনটি লিস্টিং ৮-১৮-তে দেখানো হয়েছে।

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used
}

s3 স্ট্রিংটিতে Hello, world! থাকবে। s1 যোগ করার পরে আর বৈধ থাকে না এবং আমরা s2-এর একটি রেফারেন্স ব্যবহার করেছি, এর কারণটি সেই মেথডের সিগনেচারের সাথে সম্পর্কিত যা + অপারেটর ব্যবহার করার সময় কল করা হয়। + অপারেটরটি add মেথড ব্যবহার করে, যার সিগনেচারটি প্রায় এরকম:

fn add(self, s: &str) -> String {

Standard library-তে, আপনি add মেথডটি জেনেরিক এবং অ্যাসোসিয়েটেড টাইপ ব্যবহার করে সংজ্ঞায়িত দেখতে পাবেন। এখানে, আমরা সুনির্দিষ্ট টাইপ ব্যবহার করেছি, যা ঘটে যখন আমরা String ভ্যালু দিয়ে এই মেথডটি কল করি। আমরা অধ্যায় ১০-এ জেনেরিক নিয়ে আলোচনা করব। এই সিগনেচারটি আমাদের + অপারেটরের জটিল অংশগুলো বোঝার জন্য প্রয়োজনীয় সূত্র দেয়।

প্রথমত, s2-এর একটি & আছে, যার মানে আমরা প্রথম স্ট্রিং-এর সাথে দ্বিতীয় স্ট্রিং-এর একটি রেফারেন্স যোগ করছি। এটি add ফাংশনের s প্যারামিটারের কারণে: আমরা শুধুমাত্র একটি &str একটি String-এ যোগ করতে পারি; আমরা দুটি String ভ্যালু একসাথে যোগ করতে পারি না। কিন্তু অপেক্ষা করুন—&s2-এর টাইপ হলো &String, &str নয়, যেমনটি add-এর দ্বিতীয় প্যারামিটারে নির্দিষ্ট করা আছে। তাহলে লিস্টিং ৮-১৮ কেন কম্পাইল হয়?

add কলে &s2 ব্যবহার করতে পারার কারণ হলো কম্পাইলার &String আর্গুমেন্টটিকে একটি &str-এ coerce (রূপান্তর) করতে পারে। যখন আমরা add মেথডটি কল করি, Rust একটি deref coercion ব্যবহার করে, যা এখানে &s2-কে &s2[..]-তে পরিণত করে। আমরা অধ্যায় ১৫-এ deref coercion নিয়ে আরও বিস্তারিত আলোচনা করব। যেহেতু add s প্যারামিটারের মালিকানা নেয় না, তাই এই অপারেশনের পরেও s2 একটি বৈধ String থাকবে।

দ্বিতীয়ত, আমরা সিগনেচারে দেখতে পাচ্ছি যে add self-এর মালিকানা নেয় কারণ self-এর আগে & নেই। এর মানে লিস্টিং ৮-১৮-এর s1 add কলের মধ্যে মুভ (move) হয়ে যাবে এবং তারপরে আর বৈধ থাকবে না। সুতরাং, যদিও let s3 = s1 + &s2; দেখে মনে হচ্ছে এটি উভয় স্ট্রিং কপি করে একটি নতুন তৈরি করবে, এই স্টেটমেন্টটি আসলে s1-এর মালিকানা নেয়, s2-এর বিষয়বস্তুর একটি কপি যোগ করে এবং তারপর ফলাফলের মালিকানা ফেরত দেয়। অন্য কথায়, এটি দেখতে অনেক কপি করার মতো মনে হলেও, এর বাস্তবায়ন কপি করার চেয়ে অনেক বেশি কার্যকর।

যদি আমাদের একাধিক স্ট্রিং যুক্ত করতে হয়, তাহলে + অপারেটরের ব্যবহার বেশ громоздким (unwieldy) হয়ে যায়:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

এই মুহুর্তে, s হবে tic-tac-toe। এতগুলো + এবং " অক্ষরের কারণে কী ঘটছে তা বোঝা কঠিন। আরও জটিল উপায়ে স্ট্রিং একত্রিত করার জন্য, আমরা এর পরিবর্তে format! ম্যাক্রো ব্যবহার করতে পারি:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

এই কোডটি s-কে tic-tac-toe-তে সেট করে। format! ম্যাক্রো println!-এর মতো কাজ করে, কিন্তু আউটপুট স্ক্রিনে প্রিন্ট করার পরিবর্তে, এটি বিষয়বস্তুসহ একটি String ফেরত দেয়। format! ব্যবহার করা কোডের সংস্করণটি পড়া অনেক সহজ, এবং format! ম্যাক্রো দ্বারা তৈরি কোড রেফারেন্স ব্যবহার করে যাতে এই কলটি তার কোনো প্যারামিটারের মালিকানা না নেয়।

স্ট্রিং-এ ইনডেক্সিং

অন্যান্য অনেক প্রোগ্রামিং ল্যাঙ্গুয়েজে, ইনডেক্স দ্বারা একটি স্ট্রিং-এর স্বতন্ত্র অক্ষর অ্যাক্সেস করা একটি বৈধ এবং সাধারণ অপারেশন। যাইহোক, আপনি যদি Rust-এ ইনডেক্সিং সিনট্যাক্স ব্যবহার করে একটি String-এর অংশ অ্যাক্সেস করার চেষ্টা করেন, আপনি একটি এরর পাবেন। লিস্টিং ৮-১৯-এর অবৈধ কোডটি বিবেচনা করুন।

fn main() {
    let s1 = String::from("hi");
    let h = s1[0];
}

এই কোডটি নিম্নলিখিত এরর দেবে:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
          but trait `SliceIndex<[_]>` is implemented for `usize`
  = help: for that trait implementation, expected `[_]`, found `str`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

এরর এবং নোটটি পুরো গল্পটি বলে দেয়: Rust স্ট্রিং ইনডেক্সিং সমর্থন করে না। কিন্তু কেন নয়? এই প্রশ্নের উত্তর দিতে, আমাদের আলোচনা করতে হবে Rust কীভাবে মেমরিতে স্ট্রিং স্টোর করে।

অভ্যন্তরীণ উপস্থাপনা (Internal Representation)

একটি String হলো Vec<u8>-এর উপর একটি র‍্যাপার। আসুন লিস্টিং ৮-১৪ থেকে আমাদের সঠিকভাবে এনকোড করা UTF-8 উদাহরণ স্ট্রিংগুলির কিছু দেখি। প্রথমত, এটি:

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

এই ক্ষেত্রে, len হবে 4, যার মানে "Hola" স্ট্রিংটি স্টোর করা ভেক্টরটি ৪ বাইট দীর্ঘ। UTF-8-এ এনকোড করার সময় এই অক্ষরগুলির প্রতিটি এক বাইট করে জায়গা নেয়। তবে, নিম্নলিখিত লাইনটি আপনাকে অবাক করতে পারে (লক্ষ্য করুন যে এই স্ট্রিংটি ক্যাপিটাল সিরিলিক অক্ষর Ze দিয়ে শুরু হয়, সংখ্যা 3 দিয়ে নয়):

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

আপনাকে যদি জিজ্ঞাসা করা হয় স্ট্রিংটি কত দীর্ঘ, আপনি হয়তো বলবেন ১২। আসলে, Rust-এর উত্তর হলো ২৪: এটি "Здравствуйте" শব্দটি UTF-8-এ এনকোড করতে প্রয়োজনীয় বাইটের সংখ্যা, কারণ সেই স্ট্রিং-এর প্রতিটি ইউনিকোড স্কেলার ভ্যালু ২ বাইট স্টোরেজ নেয়। অতএব, স্ট্রিং-এর বাইটগুলিতে একটি ইনডেক্স সবসময় একটি বৈধ ইউনিকোড স্কেলার ভ্যালুর সাথে মিলবে না। এটি দেখানোর জন্য, এই অবৈধ Rust কোডটি বিবেচনা করুন:

let hello = "Здравствуйте";
let answer = &hello[0];

আপনি ಈಗಾಗಲೇ জানেন যে answer З হবে না, যা প্রথম অক্ষর। UTF-8-এ এনকোড করা হলে, З-এর প্রথম বাইট হলো 208 এবং দ্বিতীয়টি হলো 151, তাই মনে হতে পারে যে answer আসলে 208 হওয়া উচিত, কিন্তু 208 নিজে থেকে একটি বৈধ অক্ষর নয়। যদি কেউ এই স্ট্রিংয়ের প্রথম অক্ষরের জন্য জিজ্ঞাসা করে তবে 208 ফেরত দেওয়া সম্ভবত ব্যবহারকারীর কাঙ্ক্ষিত হবে না; তবে, বাইট ইনডেক্স ০-তে Rust-এর কাছে কেবল এই ডেটাই আছে। ব্যবহারকারীরা সাধারণত বাইট ভ্যালু ফেরত চান না, এমনকি যদি স্ট্রিংটিতে শুধুমাত্র ল্যাটিন অক্ষর থাকে: যদি &"hi"[0] বৈধ কোড হতো যা বাইট ভ্যালু ফেরত দিত, তবে এটি h-এর পরিবর্তে 104 ফেরত দিত।

উত্তরটি হলো, একটি অপ্রত্যাশিত মান ফেরত দেওয়া এবং এমন বাগ তৈরি করা এড়াতে যা অবিলম্বে আবিষ্কৃত নাও হতে পারে, Rust এই কোডটি মোটেই কম্পাইল করে না এবং ডেভেলপমেন্ট প্রক্রিয়ার শুরুতেই ভুল বোঝাবুঝি প্রতিরোধ করে।

বাইট, স্কেলার ভ্যালু এবং গ্রাফিম ক্লাস্টার! এলাহি কাণ্ড!

UTF-8 সম্পর্কে আরেকটি বিষয় হলো যে Rust-এর দৃষ্টিকোণ থেকে স্ট্রিং দেখার তিনটি প্রাসঙ্গিক উপায় রয়েছে: বাইট হিসাবে, স্কেলার ভ্যালু হিসাবে, এবং গ্রাফিম ক্লাস্টার হিসাবে (যাকে আমরা অক্ষর বলি তার সবচেয়ে কাছের জিনিস)।

যদি আমরা দেবনাগরী লিপিতে লেখা হিন্দি শব্দ "नमस्ते" দেখি, এটি u8 ভ্যালুর একটি ভেক্টর হিসাবে স্টোর করা হয় যা দেখতে এইরকম:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

এটি ১৮ বাইট এবং কম্পিউটারগুলি এভাবেই ডেটা সঞ্চয় করে। যদি আমরা এগুলিকে ইউনিকোড স্কেলার ভ্যালু হিসাবে দেখি, যা Rust-এর char টাইপ, তবে সেই বাইটগুলি দেখতে এইরকম:

['न', 'म', 'स', '्', 'त', 'े']

এখানে ছয়টি char ভ্যালু রয়েছে, কিন্তু চতুর্থ এবং ষষ্ঠটি অক্ষর নয়: সেগুলি ডায়াক্রিটিক যা নিজে থেকে অর্থপূর্ণ নয়। অবশেষে, যদি আমরা এগুলিকে গ্রাফিম ক্লাস্টার হিসাবে দেখি, তবে আমরা সেই চারটি অক্ষর পাব যা একজন ব্যক্তি হিন্দি শব্দটি তৈরি করতে ব্যবহার করবে:

["न", "म", "स्", "ते"]

Rust কম্পিউটার দ্বারা সংরক্ষিত কাঁচা স্ট্রিং ডেটা ব্যাখ্যা করার বিভিন্ন উপায় সরবরাহ করে যাতে প্রতিটি প্রোগ্রাম তার প্রয়োজনীয় ব্যাখ্যা বেছে নিতে পারে, ডেটা যে কোনো মানব ভাষায়ই হোক না কেন।

Rust আমাদের একটি অক্ষর পেতে একটি String-এ ইনডেক্স করার অনুমতি না দেওয়ার একটি চূড়ান্ত কারণ হলো যে ইনডেক্সিং অপারেশনগুলি সর্বদা ধ্রুবক সময়ে (O(1)) সম্পন্ন হবে বলে আশা করা হয়। কিন্তু একটি String-এর সাথে সেই পারফরম্যান্সের গ্যারান্টি দেওয়া সম্ভব নয়, কারণ Rust-কে শুরু থেকে ইনডেক্স পর্যন্ত বিষয়বস্তুর মধ্যে দিয়ে হেঁটে যেতে হবে কতগুলি বৈধ অক্ষর ছিল তা নির্ধারণ করার জন্য।

স্ট্রিং স্লাইস করা

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

একটি একক সংখ্যা দিয়ে [] ব্যবহার করে ইনডেক্স করার পরিবর্তে, আপনি নির্দিষ্ট বাইট ধারণকারী একটি স্ট্রিং স্লাইস তৈরি করতে একটি পরিসীমা (range) সহ [] ব্যবহার করতে পারেন:

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

এখানে, s একটি &str হবে যা স্ট্রিং-এর প্রথম চারটি বাইট ধারণ করে। আগে, আমরা উল্লেখ করেছি যে এই অক্ষরগুলির প্রতিটি দুই বাইট করে ছিল, যার মানে s হবে Зд।

যদি আমরা &hello[0..1]-এর মতো কিছু দিয়ে একটি অক্ষরের বাইটের কেবল একটি অংশ স্লাইস করার চেষ্টা করতাম, তাহলে Rust রানটাইমে প্যানিক করত, যেমন একটি ভেক্টরে একটি অবৈধ ইনডেক্স অ্যাক্সেস করা হলে হয়:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`

thread 'main' panicked at src/main.rs:4:19:
byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

রেঞ্জ ব্যবহার করে স্ট্রিং স্লাইস তৈরি করার সময় আপনার সতর্কতা অবলম্বন করা উচিত, কারণ এটি আপনার প্রোগ্রাম ক্র্যাশ করতে পারে।

স্ট্রিং-এর উপর ইটারেট করার মেথড

স্ট্রিং-এর অংশে কাজ করার সেরা উপায় হলো আপনি অক্ষর চান নাকি বাইট চান সে সম্পর্কে স্পষ্ট হওয়া। স্বতন্ত্র ইউনিকোড স্কেলার ভ্যালুর জন্য, chars মেথড ব্যবহার করুন। "Зд"-এর উপর chars কল করা হলে এটি দুটি char টাইপের ভ্যালু আলাদা করে ফেরত দেয়, এবং আপনি প্রতিটি এলিমেন্ট অ্যাক্সেস করতে ফলাফলের উপর ইটারেট করতে পারেন:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

এই কোডটি নিম্নলিখিত আউটপুট প্রিন্ট করবে:

З
д

বিকল্পভাবে, bytes মেথড প্রতিটি কাঁচা বাইট ফেরত দেয়, যা আপনার ডোমেনের জন্য উপযুক্ত হতে পারে:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

এই কোডটি এই স্ট্রিংটি গঠনকারী চারটি বাইট প্রিন্ট করবে:

208
151
208
180

তবে মনে রাখতে ভুলবেন না যে বৈধ ইউনিকোড স্কেলার ভ্যালু একাধিক বাইট দিয়ে গঠিত হতে পারে।

দেবনাগরী লিপির মতো স্ট্রিং থেকে গ্রাফিম ক্লাস্টার পাওয়া জটিল, তাই এই কার্যকারিতা standard library দ্বারা সরবরাহ করা হয় না। যদি আপনার এই কার্যকারিতার প্রয়োজন হয়, তাহলে crates.io-তে ক্রেট উপলব্ধ আছে।

স্ট্রিং অতটা সহজ নয়

সংক্ষেপে, স্ট্রিং বেশ জটিল। বিভিন্ন প্রোগ্রামিং ল্যাঙ্গুয়েজ প্রোগ্রামারদের কাছে এই জটিলতা কীভাবে উপস্থাপন করা হবে সে সম্পর্কে বিভিন্ন সিদ্ধান্ত নেয়। Rust String ডেটার সঠিক হ্যান্ডলিং-কে সমস্ত Rust প্রোগ্রামের জন্য ডিফল্ট আচরণ হিসাবে বেছে নিয়েছে, যার মানে প্রোগ্রামারদের UTF-8 ডেটা হ্যান্ডলিং নিয়ে আগে থেকেই আরও বেশি ভাবতে হবে। এই ট্রেড-অফটি অন্যান্য প্রোগ্রামিং ল্যাঙ্গুয়েজে দৃশ্যমান স্ট্রিং-এর জটিলতার চেয়ে বেশি প্রকাশ করে, তবে এটি আপনাকে আপনার ডেভেলপমেন্ট লাইফ সাইকেলের পরবর্তী পর্যায়ে নন-ASCII অক্ষর সম্পর্কিত এরর হ্যান্ডলিং করা থেকে বিরত রাখে।

সুখবর হলো, standard library String এবং &str টাইপের উপর ভিত্তি করে অনেক কার্যকারিতা সরবরাহ করে যা এই জটিল পরিস্থিতিগুলি সঠিকভাবে পরিচালনা করতে সহায়তা করে। স্ট্রিং-এ অনুসন্ধানের জন্য contains এবং স্ট্রিং-এর অংশ অন্য স্ট্রিং দিয়ে প্রতিস্থাপনের জন্য replace-এর মতো দরকারি মেথডগুলির জন্য ডকুমেন্টেশন দেখতে ভুলবেন না।

চলুন এবার একটু কম জটিল কিছুতে যাওয়া যাক: hash maps

Hash Map ব্যবহার করে Key এবং সংশ্লিষ্ট Value স্টোর করা

আমাদের সাধারণ collection-গুলোর মধ্যে সর্বশেষটি হলো hash map। HashMap<K, V> টাইপটি K টাইপের key-এর সাথে V টাইপের value-এর একটি ম্যাপিং সংরক্ষণ করে। এটি একটি hashing function ব্যবহার করে নির্ধারণ করে কীভাবে মেমরিতে এই key এবং value-গুলো রাখা হবে। অনেক প্রোগ্রামিং ল্যাঙ্গুয়েজ এই ধরনের ডেটা স্ট্রাকচার সমর্থন করে, কিন্তু তারা প্রায়শই ভিন্ন নাম ব্যবহার করে, যেমন hash, map, object, hash table, dictionary, বা associative array ইত্যাদি।

Hash map তখন দরকারী যখন আপনি কোনো index ব্যবহার করে ডেটা খুঁজতে চান না (যেমনটা vector-এর ক্ষেত্রে করা হয়), বরং একটি key ব্যবহার করে ডেটা খুঁজতে চান যা যেকোনো টাইপের হতে পারে। উদাহরণস্বরূপ, একটি গেমে, আপনি প্রতিটি দলের স্কোর একটি hash map-এ রাখতে পারেন, যেখানে প্রতিটি key হলো দলের নাম এবং value হলো সেই দলের স্কোর। একটি দলের নাম দিয়ে আপনি তার স্কোর পুনরুদ্ধার করতে পারবেন।

এই বিভাগে আমরা hash map-এর বেসিক API নিয়ে আলোচনা করব, কিন্তু standard library দ্বারা HashMap<K, V>-তে সংজ্ঞায়িত ফাংশনগুলিতে আরও অনেক সুবিধা লুকিয়ে আছে। বরাবরের মতো, আরও তথ্যের জন্য standard library-এর ডকুমেন্টেশন দেখুন।

নতুন Hash Map তৈরি করা

একটি খালি hash map তৈরি করার একটি উপায় হলো new ব্যবহার করা এবং insert দিয়ে element যোগ করা। লিস্টিং ৮-২০-এ, আমরা দুটি দলের স্কোর ট্র্যাক করছি যাদের নাম Blue এবং Yellow। Blue দলের স্কোর ১০ দিয়ে শুরু হয় এবং Yellow দলের ৫০ দিয়ে।

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
}

লক্ষ্য করুন যে আমাদের প্রথমে standard library-এর collections অংশ থেকে HashMap use করতে হবে। আমাদের তিনটি সাধারণ collection-এর মধ্যে এটি সবচেয়ে কম ব্যবহৃত হয়, তাই এটি prelude-এ স্বয়ংক্রিয়ভাবে স্কোপে আনা ফিচারগুলোর অন্তর্ভুক্ত নয়। Hash map-এর জন্য standard library থেকে কম সমর্থনও রয়েছে; উদাহরণস্বরূপ, এটি তৈরি করার জন্য কোনো বিল্ট-ইন ম্যাক্রো নেই।

Vector-এর মতোই, hash map তাদের ডেটা heap-এ স্টোর করে। এই HashMap-এর key-গুলো String টাইপের এবং value-গুলো i32 টাইপের। Vector-এর মতোই, hash map-ও সমজাতীয় (homogeneous): সমস্ত key-এর টাইপ একই হতে হবে এবং সমস্ত value-এর টাইপও একই হতে হবে।

Hash Map-এর Value অ্যাক্সেস করা

আমরা hash map থেকে একটি value পেতে পারি তার key get মেথডে সরবরাহ করে, যেমনটি লিস্টিং ৮-২১-এ দেখানো হয়েছে।

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    let team_name = String::from("Blue");
    let score = scores.get(&team_name).copied().unwrap_or(0);
}

এখানে, score-এর ভ্যালু হবে Blue দলের সাথে যুক্ত ভ্যালুটি, এবং ফলাফল হবে 10। get মেথডটি একটি Option<&V> রিটার্ন করে; যদি hash map-এ সেই key-এর জন্য কোনো ভ্যালু না থাকে, get None রিটার্ন করবে। এই প্রোগ্রামটি Option-কে copied কল করে একটি Option<i32> পায় (Option<&i32>-এর পরিবর্তে), তারপর unwrap_or ব্যবহার করে score-কে শূন্যতে সেট করে যদি scores-এ key-টির জন্য কোনো এন্ট্রি না থাকে।

আমরা একটি for লুপ ব্যবহার করে hash map-এর প্রতিটি key-value পেয়ারের উপর দিয়ে ইটারেট করতে পারি, যেমনটা আমরা vector-এর সাথে করি:

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    for (key, value) in &scores {
        println!("{key}: {value}");
    }
}

এই কোডটি প্রতিটি জোড়া একটি অনির্দিষ্ট ক্রমে প্রিন্ট করবে:

Yellow: 50
Blue: 10

Hash Map এবং Ownership

যেসব টাইপ Copy trait ইমপ্লিমেন্ট করে, যেমন i32, সেগুলোর ভ্যালু hash map-এ কপি হয়। String-এর মতো owned ভ্যালুর ক্ষেত্রে, ভ্যালুগুলো মুভ (move) হবে এবং hash map সেই ভ্যালুগুলোর মালিক হবে, যেমনটি লিস্টিং ৮-২২-এ দেখানো হয়েছে।

fn main() {
    use std::collections::HashMap;

    let field_name = String::from("Favorite color");
    let field_value = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_name, field_value);
    // field_name and field_value are invalid at this point, try using them and
    // see what compiler error you get!
}

insert কলের মাধ্যমে field_name এবং field_value ভ্যারিয়েবলগুলো hash map-এ মুভ হয়ে যাওয়ার পরে আমরা আর সেগুলো ব্যবহার করতে পারি না।

যদি আমরা hash map-এ ভ্যালুর রেফারেন্স যুক্ত করি, তবে ভ্যালুগুলো hash map-এ মুভ হবে না। রেফারেন্সগুলো যে ভ্যালুকে নির্দেশ করে, সেই ভ্যালুগুলো অন্তত hash map যতদিন বৈধ থাকবে, ততদিন বৈধ থাকতে হবে। আমরা এই বিষয়গুলো নিয়ে অধ্যায় ১০-এর “Validating References with Lifetimes” বিভাগে আরও আলোচনা করব।

একটি Hash Map আপডেট করা

যদিও key-value পেয়ারের সংখ্যা বাড়ানো যায়, প্রতিটি স্বতন্ত্র key-এর সাথে একবারে কেবল একটিই value যুক্ত থাকতে পারে (কিন্তু এর বিপরীতটি সত্য নয়: উদাহরণস্বরূপ, Blue এবং Yellow উভয় দলেরই scores hash map-এ 10 ভ্যালুটি থাকতে পারে)।

যখন আপনি একটি hash map-এর ডেটা পরিবর্তন করতে চান, তখন আপনাকে সিদ্ধান্ত নিতে হবে যে একটি key-তে যখন আগে থেকেই একটি value বরাদ্দ থাকে তখন কী করবেন। আপনি পুরানো ভ্যালুটিকে সম্পূর্ণ উপেক্ষা করে নতুন ভ্যালু দিয়ে প্রতিস্থাপন করতে পারেন। আপনি পুরানো ভ্যালুটি রেখে নতুন ভ্যালুটি উপেক্ষা করতে পারেন, এবং শুধুমাত্র যদি key-টির কোনো ভ্যালু না থাকে তবেই নতুন ভ্যালু যোগ করতে পারেন। অথবা আপনি পুরানো এবং নতুন ভ্যালু একত্রিত করতে পারেন। আসুন দেখি কীভাবে এর প্রতিটি করা যায়!

একটি ভ্যালু ওভাররাইট করা

যদি আমরা একটি hash map-এ একটি key এবং একটি value যুক্ত করি এবং তারপরে একই key দিয়ে ভিন্ন একটি value যুক্ত করি, তবে সেই key-এর সাথে যুক্ত value প্রতিস্থাপিত হবে। যদিও লিস্টিং ৮-২৩-এর কোডটি দুবার insert কল করে, hash map-এ কেবল একটি key-value পেয়ার থাকবে কারণ আমরা উভয়বারই Blue দলের key-এর জন্য value যুক্ত করছি।

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25);

    println!("{scores:?}");
}

এই কোডটি {"Blue": 25} প্রিন্ট করবে। আসল 10 ভ্যালুটি ওভাররাইট করা হয়েছে।

শুধুমাত্র Key উপস্থিত না থাকলে একটি Key এবং Value যোগ করা

একটি সাধারণ কাজ হলো hash map-এ একটি নির্দিষ্ট key-এর জন্য কোনো value আছে কিনা তা পরীক্ষা করা এবং তারপরে নিম্নলিখিত পদক্ষেপ নেওয়া: যদি key-টি hash map-এ থাকে, তবে বিদ্যমান value অপরিবর্তিত থাকবে; যদি key-টি না থাকে, তবে এটি এবং এর জন্য একটি value যুক্ত করা হবে।

Hash map-এর এর জন্য একটি বিশেষ API আছে যার নাম entry, যা প্যারামিটার হিসাবে আপনি যে key পরীক্ষা করতে চান তা নেয়। entry মেথডের রিটার্ন ভ্যালু হলো Entry নামের একটি enum, যা এমন একটি ভ্যালুকে প্রতিনিধিত্ব করে যা থাকতেও পারে বা নাও থাকতে পারে। ধরা যাক আমরা পরীক্ষা করতে চাই Yellow দলের key-এর সাথে কোনো value যুক্ত আছে কিনা। যদি না থাকে, আমরা 50 ভ্যালুটি যুক্ত করতে চাই, এবং Blue দলের জন্যও একই কাজ করতে চাই। entry API ব্যবহার করে কোডটি লিস্টিং ৮-২৪-এর মতো দেখায়।

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);

    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50);

    println!("{scores:?}");
}

Entry-এর উপর or_insert মেথডটি এমনভাবে সংজ্ঞায়িত করা হয়েছে যে এটি সংশ্লিষ্ট Entry key-এর ভ্যালুর একটি mutable রেফারেন্স রিটার্ন করে যদি সেই key বিদ্যমান থাকে, এবং যদি না থাকে, তবে এটি প্যারামিটারটিকে এই key-এর নতুন ভ্যালু হিসাবে যুক্ত করে এবং নতুন ভ্যালুর একটি mutable রেফারেন্স রিটার্ন করে। এই কৌশলটি নিজেরা লজিক লেখার চেয়ে অনেক পরিষ্কার এবং borrow checker-এর সাথে আরও ভালোভাবে কাজ করে।

লিস্টিং ৮-২৪-এর কোডটি চালালে {"Yellow": 50, "Blue": 10} প্রিন্ট হবে। প্রথম entry কলটি Yellow দলের key 50 ভ্যালুসহ যুক্ত করবে কারণ Yellow দলের আগে থেকে কোনো ভ্যালু নেই। দ্বিতীয় entry কলটি hash map পরিবর্তন করবে না কারণ Blue দলের আগে থেকেই 10 ভ্যালুটি রয়েছে।

পুরানো ভ্যালুর উপর ভিত্তি করে একটি ভ্যালু আপডেট করা

Hash map-এর আরেকটি সাধারণ ব্যবহার হলো একটি key-এর ভ্যালু খুঁজে বের করা এবং তারপর পুরানো ভ্যালুর উপর ভিত্তি করে এটি আপডেট করা। উদাহরণস্বরূপ, লিস্টিং ৮-২৫-এর কোডটি গণনা করে যে কিছু টেক্সটে প্রতিটি শব্দ কতবার আসে। আমরা শব্দগুলোকে key হিসাবে এবং তাদের সংখ্যা ট্র্যাক করার জন্য ভ্যালু বৃদ্ধি করে একটি hash map ব্যবহার করি। যদি আমরা প্রথমবার কোনো শব্দ দেখি, আমরা প্রথমে 0 ভ্যালুটি যুক্ত করব।

fn main() {
    use std::collections::HashMap;

    let text = "hello world wonderful world";

    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{map:?}");
}

এই কোডটি {"world": 2, "hello": 1, "wonderful": 1} প্রিন্ট করবে। আপনি একই key-value পেয়ারগুলো ভিন্ন ক্রমে প্রিন্ট করা দেখতে পারেন: “Accessing Values in a Hash Map” থেকে মনে করুন যে একটি hash map-এর উপর ইটারেট করা একটি অনির্দিষ্ট ক্রমে ঘটে।

split_whitespace মেথডটি text-এর ভ্যালুর হোয়াইটস্পেস দ্বারা পৃথক করা সাবস্লাইসের উপর একটি ইটারেটর রিটার্ন করে। or_insert মেথডটি নির্দিষ্ট key-এর ভ্যালুর একটি mutable রেফারেন্স (&mut V) রিটার্ন করে। এখানে, আমরা সেই mutable রেফারেন্সটি count ভ্যারিয়েবলে সংরক্ষণ করি, তাই সেই ভ্যালুতে অ্যাসাইন করার জন্য, আমাদের প্রথমে অ্যাস্টারিস্ক (*) ব্যবহার করে count-কে dereference করতে হবে। Mutable রেফারেন্সটি for লুপের শেষে স্কোপের বাইরে চলে যায়, তাই এই সমস্ত পরিবর্তনগুলি নিরাপদ এবং borrowing rules দ্বারা অনুমোদিত।

হ্যাশিং ফাংশন (Hashing Functions)

ডিফল্টরূপে, HashMap SipHash নামের একটি হ্যাশিং ফাংশন ব্যবহার করে যা denial-of-service (DoS) আক্রমণের বিরুদ্ধে প্রতিরোধ প্রদান করতে পারে¹। এটি উপলব্ধ দ্রুততম হ্যাশিং অ্যালগরিদম নয়, কিন্তু পারফরম্যান্স হ্রাসের বিনিময়ে যে উন্নত নিরাপত্তা পাওয়া যায় তা মূল্যবান। যদি আপনি আপনার কোড প্রোফাইল করেন এবং দেখেন যে ডিফল্ট হ্যাশ ফাংশনটি আপনার উদ্দেশ্যের জন্য খুব ধীর, আপনি একটি ভিন্ন হ্যাশার নির্দিষ্ট করে অন্য ফাংশনে স্যুইচ করতে পারেন। একটি hasher হলো এমন একটি টাইপ যা BuildHasher trait ইমপ্লিমেন্ট করে। আমরা অধ্যায় ১০-এ trait এবং কীভাবে সেগুলি ইমপ্লিমেন্ট করতে হয় সে সম্পর্কে কথা বলব। আপনাকে স্ক্র্যাচ থেকে নিজের হ্যাশার ইমপ্লিমেন্ট করতে হবে না; crates.io-তে অন্যান্য Rust ব্যবহারকারীদের দ্বারা শেয়ার করা লাইব্রেরি রয়েছে যা অনেক সাধারণ হ্যাশিং অ্যালগরিদম ইমপ্লিমেন্ট করে এমন হ্যাশার সরবরাহ করে।

সারসংক্ষেপ

Vector, string, এবং hash map প্রোগ্রামগুলিতে যখন ডেটা সংরক্ষণ, অ্যাক্সেস এবং পরিবর্তন করার প্রয়োজন হয় তখন একটি বিশাল পরিমাণ কার্যকারিতা প্রদান করবে। এখানে কিছু অনুশীলন রয়েছে যা আপনি এখন সমাধান করার জন্য সজ্জিত থাকা উচিত:

১. পূর্ণসংখ্যার একটি তালিকা দেওয়া হলে, একটি vector ব্যবহার করে তালিকাটির মিডিয়ান (median - সাজানো হলে মাঝের অবস্থানের মান) এবং মোড (mode - যে মানটি সবচেয়ে বেশিবার ঘটে; এখানে একটি hash map সহায়ক হবে) রিটার্ন করুন। ২. স্ট্রিংগুলিকে পিগ ল্যাটিনে (pig latin) রূপান্তর করুন। প্রতিটি শব্দের প্রথম কনসোনেন্ট (consonant) শব্দের শেষে সরানো হয় এবং ay যোগ করা হয়, তাই first হয়ে যায় irst-fay। যে শব্দগুলি ভাওয়েল (vowel) দিয়ে শুরু হয় সেগুলির শেষে hay যোগ করা হয় (apple হয়ে যায় apple-hay)। UTF-8 এনকোডিং সম্পর্কে বিস্তারিত মনে রাখবেন! ৩. একটি hash map এবং vector ব্যবহার করে, একটি টেক্সট ইন্টারফেস তৈরি করুন যা একজন ব্যবহারকারীকে একটি কোম্পানির একটি বিভাগে কর্মচারীর নাম যুক্ত করার অনুমতি দেয়; উদাহরণস্বরূপ, “Add Sally to Engineering” বা “Add Amir to Sales”। তারপরে ব্যবহারকারীকে একটি বিভাগের সমস্ত ব্যক্তির তালিকা বা বিভাগ অনুসারে কোম্পানির সমস্ত ব্যক্তির তালিকা বর্ণানুক্রমিকভাবে সাজানো অবস্থায় পুনরুদ্ধার করার অনুমতি দিন।

Standard library API ডকুমেন্টেশন vector, string, এবং hash map-এর এমন মেথডগুলো বর্ণনা করে যা এই অনুশীলনগুলির জন্য সহায়ক হবে!

আমরা আরও জটিল প্রোগ্রামগুলিতে প্রবেশ করছি যেখানে অপারেশন ব্যর্থ হতে পারে, তাই error handling নিয়ে আলোচনা করার জন্য এটি একটি উপযুক্ত সময়। আমরা এর পরেই তা করব!

1. https://en.wikipedia.org/wiki/SipHash ↩

এরর হ্যান্ডলিং (Error Handling)

সফটওয়্যারে এরর (error) একটি বাস্তব সত্য, তাই কোনো কিছু ভুল হলে সেই পরিস্থিতি সামলানোর জন্য Rust-এ বেশ কিছু ফিচার (feature) রয়েছে। অনেক ক্ষেত্রে, Rust আপনার কোড কম্পাইল (compile) হওয়ার আগেই আপনাকে এররের সম্ভাবনা স্বীকার করতে এবং কিছু পদক্ষেপ নিতে বাধ্য করে। এই বাধ্যবাধকতা আপনার প্রোগ্রামকে আরও শক্তিশালী (robust) করে তোলে। এটি নিশ্চিত করে যে আপনি আপনার কোড প্রোডাকশনে (production) পাঠানোর আগেই এরর খুঁজে বের করবেন এবং সঠিকভাবে তা হ্যান্ডেল (handle) করবেন।

Rust এররগুলোকে প্রধান দুটি ভাগে ভাগ করে: recoverable (পুনরুদ্ধারযোগ্য) এবং unrecoverable (অপুনরুদ্ধারযোগ্য) এরর। একটি recoverable এরর, যেমন file not found এরর, এর ক্ষেত্রে আমরা সাধারণত ব্যবহারকারীকে সমস্যাটি জানাতে এবং অপারেশনটি আবার চেষ্টা করতে চাই। Unrecoverable এররগুলো সবসময় বাগের (bug) লক্ষণ, যেমন একটি array-এর সীমার বাইরের কোনো লোকেশন অ্যাক্সেস করার চেষ্টা করা। এক্ষেত্রে আমরা প্রোগ্রামটি অবিলম্বে বন্ধ করে দিতে চাই।

বেশিরভাগ ল্যাঙ্গুয়েজ এই দুই ধরনের এররের মধ্যে পার্থক্য করে না এবং উভয়কেই একই উপায়ে, যেমন exceptions ব্যবহার করে, হ্যান্ডেল করে। Rust-এ exceptions নেই। এর পরিবর্তে, recoverable এররের জন্য Result<T, E> টাইপ এবং unrecoverable এররের ক্ষেত্রে প্রোগ্রাম থামিয়ে দেওয়ার জন্য panic! ম্যাক্রো রয়েছে। এই অধ্যায়ে প্রথমে panic! কল করা এবং তারপর Result<T, E> ভ্যালু রিটার্ন করা নিয়ে আলোচনা করা হবে। এছাড়াও, আমরা একটি এরর থেকে রিকভার করার চেষ্টা করা হবে নাকি এক্সিকিউশন বন্ধ করে দেওয়া হবে, এই সিদ্ধান্ত নেওয়ার সময় বিবেচ্য বিষয়গুলোও খতিয়ে দেখব।

panic! দিয়ে অপুনরুদ্ধারযোগ্য এরর (Unrecoverable Errors)

কখনও কখনও আপনার কোডে খারাপ কিছু ঘটে, এবং আপনি তা নিয়ে কিছুই করতে পারেন না। এই ধরনের ক্ষেত্রে, Rust-এ panic! ম্যাক্রো রয়েছে। বাস্তবে প্যানিক (panic) ঘটানোর দুটি উপায় আছে: এমন কোনো কাজ করা যা আমাদের কোডকে প্যানিক করায় (যেমন একটি array-এর সীমার বাইরে অ্যাক্সেস করা) অথবা স্পষ্টভাবে panic! ম্যাক্রো কল করা। উভয় ক্ষেত্রেই, আমরা আমাদের প্রোগ্রামে একটি প্যানিক ঘটাই। ডিফল্টভাবে, এই প্যানিকগুলো একটি ব্যর্থতার বার্তা প্রিন্ট করবে, স্ট্যাক আনওয়াইন্ড (unwind) করবে, পরিষ্কার করবে এবং প্রোগ্রাম থেকে বেরিয়ে যাবে। একটি এনভায়রনমেন্ট ভেরিয়েবলের মাধ্যমে, আপনি প্যানিকের উৎস খুঁজে বের করা সহজ করার জন্য প্যানিক ঘটলে Rust-কে কল স্ট্যাক (call stack) প্রদর্শন করাতেও পারেন।

প্যানিকের প্রতিক্রিয়ায় স্ট্যাক আনওয়াইন্ড করা বা অ্যাবোর্ট করা (Unwinding the Stack or Aborting in Response to a Panic)

ডিফল্টভাবে, যখন একটি প্যানিক ঘটে, প্রোগ্রামটি unwinding শুরু করে, যার মানে হলো Rust স্ট্যাকের উপরে ফিরে যায় এবং প্রতিটি ফাংশন থেকে ডেটা পরিষ্কার করে। তবে, এভাবে ফিরে যাওয়া এবং পরিষ্কার করা অনেক কাজ। তাই Rust আপনাকে অবিলম্বে aborting (বন্ধ করা) এর বিকল্প বেছে নেওয়ার সুযোগ দেয়, যা কোনো কিছু পরিষ্কার না করেই প্রোগ্রামটি শেষ করে দেয়।

প্রোগ্রাম যে মেমরি ব্যবহার করছিল তা তখন অপারেটিং সিস্টেম দ্বারা পরিষ্কার করার প্রয়োজন হবে। যদি আপনার প্রকল্পে ফলস্বরূপ বাইনারিটিকে যতটা সম্ভব ছোট করার প্রয়োজন হয়, তবে আপনি আপনার Cargo.toml ফাইলের উপযুক্ত [profile] বিভাগে panic = 'abort' যোগ করে প্যানিকের সময় unwinding থেকে aborting-এ স্যুইচ করতে পারেন। উদাহরণস্বরূপ, যদি আপনি রিলিজ মোডে প্যানিকের সময় অ্যাবোর্ট করতে চান, তবে এটি যোগ করুন:

[profile.release]
panic = 'abort'

আসুন একটি সহজ প্রোগ্রামে panic! কল করার চেষ্টা করি:

fn main() {
    panic!("crash and burn");
}

আপনি যখন প্রোগ্রামটি চালাবেন, তখন আপনি এইরকম কিছু দেখতে পাবেন:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.25s
     Running `target/debug/panic`

thread 'main' panicked at src/main.rs:2:5:
crash and burn
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

panic!-এর কলটি শেষ দুটি লাইনে থাকা এরর বার্তাটির কারণ। প্রথম লাইনটি আমাদের প্যানিক বার্তা এবং আমাদের সোর্স কোডের সেই স্থানটি দেখায় যেখানে প্যানিক ঘটেছে: src/main.rs:2:5 নির্দেশ করে যে এটি আমাদের src/main.rs ফাইলের দ্বিতীয় লাইনের পঞ্চম অক্ষর।

এই ক্ষেত্রে, নির্দেশিত লাইনটি আমাদের কোডের অংশ, এবং যদি আমরা সেই লাইনে যাই, আমরা panic! ম্যাক্রো কলটি দেখতে পাই। অন্যান্য ক্ষেত্রে, panic! কলটি এমন কোডে থাকতে পারে যা আমাদের কোড কল করে, এবং এরর বার্তা দ্বারা রিপোর্ট করা ফাইলের নাম এবং লাইন নম্বর অন্য কারো কোডের হবে যেখানে panic! ম্যাক্রো কল করা হয়েছে, আমাদের কোডের সেই লাইন নয় যা অবশেষে panic! কলের কারণ হয়েছে।

আমরা panic! কলটি যে ফাংশনগুলো থেকে এসেছে তার ব্যাকট্রেস (backtrace) ব্যবহার করে আমাদের কোডের কোন অংশটি সমস্যার কারণ তা খুঁজে বের করতে পারি। একটি panic! ব্যাকট্রেস কীভাবে ব্যবহার করতে হয় তা বোঝার জন্য, আসুন আরেকটি উদাহরণ দেখি এবং দেখি যখন আমাদের কোডের কোনো বাগের কারণে কোনো লাইব্রেরি থেকে panic! কল আসে, আমাদের কোড সরাসরি ম্যাক্রো কল করার পরিবর্তে, তখন কেমন হয়। লিস্টিং ৯-১ এ কিছু কোড রয়েছে যা একটি ভেক্টরের বৈধ ইনডেক্সের সীমার বাইরে একটি ইনডেক্স অ্যাক্সেস করার চেষ্টা করে।

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

এখানে, আমরা আমাদের ভেক্টরের ১০০তম এলিমেন্টটি (যা ইনডেক্স ৯৯-এ রয়েছে কারণ ইনডেক্সিং শূন্য থেকে শুরু হয়) অ্যাক্সেস করার চেষ্টা করছি, কিন্তু ভেক্টরটিতে মাত্র তিনটি এলিমেন্ট রয়েছে। এই পরিস্থিতিতে, Rust প্যানিক করবে। [] ব্যবহার করার কথা একটি এলিমেন্ট রিটার্ন করা, কিন্তু যদি আপনি একটি অবৈধ ইনডেক্স পাস করেন, তবে এখানে এমন কোনো এলিমেন্ট নেই যা Rust সঠিকভাবে রিটার্ন করতে পারত।

C ভাষায়, একটি ডেটা স্ট্রাকচারের শেষের বাইরে পড়ার চেষ্টা করা আনডিফাইন্ড বিহেভিয়ার (undefined behavior)। আপনি মেমরির সেই অবস্থানে যা কিছু আছে তা পেতে পারেন যা ডেটা স্ট্রাকচারের সেই এলিমেন্টের সাথে সঙ্গতিপূর্ণ, যদিও মেমরিটি সেই স্ট্রাকচারের অন্তর্গত নয়। এটিকে buffer overread বলা হয় এবং এটি নিরাপত্তা দুর্বলতার কারণ হতে পারে যদি কোনো আক্রমণকারী ইনডেক্সটিকে এমনভাবে ম্যানিপুলেট করতে সক্ষম হয় যাতে সে এমন ডেটা পড়তে পারে যা তার পড়ার অনুমতি নেই এবং যা ডেটা স্ট্রাকচারের পরে সংরক্ষণ করা হয়েছে।

আপনার প্রোগ্রামকে এই ধরনের দুর্বলতা থেকে রক্ষা করার জন্য, যদি আপনি এমন একটি ইনডেক্সে একটি এলিমেন্ট পড়ার চেষ্টা করেন যা বিদ্যমান নেই, Rust এক্সিকিউশন বন্ধ করে দেবে এবং চলতে অস্বীকার করবে। আসুন এটি চেষ্টা করে দেখি:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/panic`

thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace```

এই এররটি আমাদের _main.rs_ এর ৪ নম্বর লাইনকে নির্দেশ করে যেখানে আমরা `v` ভেক্টরের ইনডেক্স `99` অ্যাক্সেস করার চেষ্টা করছি।

`note:` লাইনটি আমাদের বলছে যে আমরা `RUST_BACKTRACE` এনভায়রনমেন্ট ভেরিয়েবল সেট করে এররের কারণ কী ঘটেছে তার একটি সঠিক ব্যাকট্রেস পেতে পারি। একটি _ব্যাকট্রেস_ হলো এই পয়েন্টে পৌঁছানোর জন্য কল করা সমস্ত ফাংশনের একটি তালিকা। Rust-এ ব্যাকট্রেস অন্যান্য ল্যাঙ্গুয়েজের মতোই কাজ করে: ব্যাকট্রেস পড়ার মূল চাবিকাঠি হলো উপর থেকে শুরু করে পড়া যতক্ষণ না আপনি আপনার লেখা ফাইল দেখতে পান। সেখানেই সমস্যার উৎপত্তি। সেই স্থানের উপরের লাইনগুলো হলো কোড যা আপনার কোড কল করেছে; নীচের লাইনগুলো হলো কোড যা আপনার কোডকে কল করেছে। এই আগের এবং পরের লাইনগুলিতে কোর Rust কোড, স্ট্যান্ডার্ড লাইব্রেরি কোড, বা আপনার ব্যবহার করা ক্রেট অন্তর্ভুক্ত থাকতে পারে। আসুন `RUST_BACKTRACE` এনভায়রনমেন্ট ভেরিয়েবলকে `0` ছাড়া যেকোনো মান দিয়ে সেট করে একটি ব্যাকট্রেস পাওয়ার চেষ্টা করি। লিস্টিং ৯-২ আপনার যা দেখার সম্ভাবনা তার অনুরূপ আউটপুট দেখায়।

<!-- manual-regeneration
cd listings/ch09-error-handling/listing-09-01
RUST_BACKTRACE=1 cargo run
copy the backtrace output below
check the backtrace number mentioned in the text below the listing
-->

<Listing number="9-2" caption="`RUST_BACKTRACE` এনভায়রনমেন্ট ভেরিয়েবল সেট করা হলে `panic!` কলের দ্বারা তৈরি ব্যাকট্রেস">

```console
$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
stack backtrace:
   0: rust_begin_unwind
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/std/src/panicking.rs:692:5
   1: core::panicking::panic_fmt
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:75:14
   2: core::panicking::panic_bounds_check
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:273:5
   3: <usize as core::slice::index::SliceIndex<[T]>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:274:10
   4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:16:9
   5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:3361:9
   6: panic::main
             at ./src/main.rs:4:6
   7: core::ops::function::FnOnce::call_once
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");
}

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {error:?}"),
    };
}

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {e:?}"),
            },
            _ => {
                panic!("Problem opening the file: {error:?}");
            }
        },
    };
}

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt");

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}
}

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}
}

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("hello.txt")?.read_to_string(&mut username)?;

    Ok(username)
}
}

#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}
}

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")?;
}

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        last_char_of_first_line("Hello, world\nHow are you today?"),
        Some('d')
    );

    assert_eq!(last_char_of_first_line(""), None);
    assert_eq!(last_char_of_first_line("\nhi"), None);
}```

</Listing>

এই ফাংশনটি `Option<char>` রিটার্ন করে কারণ এটি সম্ভব যে সেখানে একটি অক্ষর আছে, কিন্তু এটিও সম্ভব যে সেখানে নেই। এই কোডটি `text` স্ট্রিং স্লাইস আর্গুমেন্টটি নেয় এবং এর উপর `lines` মেথড কল করে, যা স্ট্রিং-এর লাইনগুলোর উপর একটি ইটারেটর রিটার্ন করে। যেহেতু এই ফাংশনটি প্রথম লাইনটি পরীক্ষা করতে চায়, এটি ইটারেটরের প্রথম ভ্যালুটি পেতে ইটারেটরের উপর `next` কল করে। যদি `text` একটি খালি স্ট্রিং হয়, তবে এই `next` কলটি `None` রিটার্ন করবে, সেক্ষেত্রে আমরা `?` ব্যবহার করে `last_char_of_first_line` থেকে `None` রিটার্ন করে থেমে যাই। যদি `text` একটি খালি স্ট্রিং না হয়, `next` একটি `Some` ভ্যালু রিটার্ন করবে যা `text`-এর প্রথম লাইনের একটি স্ট্রিং স্লাইস ধারণ করে।

`?` স্ট্রিং স্লাইসটি এক্সট্র্যাক্ট করে, এবং আমরা সেই স্ট্রিং স্লাইসের উপর `chars` কল করে এর অক্ষরগুলোর একটি ইটারেটর পেতে পারি। আমরা এই প্রথম লাইনের শেষ অক্ষরে আগ্রহী, তাই আমরা ইটারেটরের শেষ আইটেমটি রিটার্ন করার জন্য `last` কল করি। এটি একটি `Option` কারণ এটি সম্ভব যে প্রথম লাইনটি একটি খালি স্ট্রিং; উদাহরণস্বরূপ, যদি `text` একটি ফাঁকা লাইন দিয়ে শুরু হয় কিন্তু অন্য লাইনে অক্ষর থাকে, যেমন `"\nhi"`। তবে, যদি প্রথম লাইনে একটি শেষ অক্ষর থাকে, তবে এটি `Some` ভ্যারিয়েন্টে রিটার্ন করা হবে। মাঝখানে `?` অপারেটরটি আমাদের এই লজিকটি সংক্ষিপ্তভাবে প্রকাশ করার একটি উপায় দেয়, যা আমাদের ফাংশনটি এক লাইনে ইমপ্লিমেন্ট করতে দেয়। যদি আমরা `Option`-এর উপর `?` অপারেটর ব্যবহার করতে না পারতাম, তবে আমাদের এই লজিকটি আরও মেথড কল বা একটি `match` এক্সপ্রেশন ব্যবহার করে ইমপ্লিমেন্ট করতে হতো।

মনে রাখবেন যে আপনি একটি ফাংশনে `Result`-এর উপর `?` অপারেটর ব্যবহার করতে পারেন যা `Result` রিটার্ন করে, এবং আপনি একটি ফাংশনে `Option`-এর উপর `?` অপারেটর ব্যবহার করতে পারেন যা `Option` রিটার্ন করে, কিন্তু আপনি মিশ্রণ করতে পারবেন না। `?` অপারেটরটি স্বয়ংক্রিয়ভাবে একটি `Result`-কে একটি `Option`-এ বা তার বিপরীতে রূপান্তর করবে না; সেই ক্ষেত্রে, আপনি স্পষ্টভাবে রূপান্তর করার জন্য `Result`-এর উপর `ok` মেথড বা `Option`-এর উপর `ok_or` মেথডের মতো মেথড ব্যবহার করতে পারেন।

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

সৌভাগ্যবশত, `main` একটি `Result<(), E>`-ও রিটার্ন করতে পারে। লিস্টিং ৯-১২-এ লিস্টিং ৯-১০-এর কোড রয়েছে, কিন্তু আমরা `main`-এর রিটার্ন টাইপ পরিবর্তন করে `Result<(), Box<dyn Error>>` করেছি এবং শেষে একটি রিটার্ন ভ্যালু `Ok(())` যোগ করেছি। এই কোডটি এখন কম্পাইল হবে।

<Listing number="9-12" file-name="src/main.rs" caption="`main`-কে `Result<(), E>` রিটার্ন করার জন্য পরিবর্তন করা `Result` ভ্যালুগুলোর উপর `?` অপারেটর ব্যবহারের অনুমতি দেয়।">

```rust,ignore
use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let greeting_file = File::open("hello.txt")?;

    Ok(())
}

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        // --snip--

        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: i32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        if guess < 1 || guess > 100 {
            println!("The secret number will be between 1 and 100.");
            continue;
        }

        match guess.cmp(&secret_number) {
            // --snip--
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

#![allow(unused)]
fn main() {
pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {value}.");
        }

        Guess { value }
    }

    pub fn value(&self) -> i32 {
        self.value
    }
}
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let mut largest = &number_list[0];

    for number in &number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {largest}");
    assert_eq!(*largest, 100);
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let mut largest = &number_list[0];

    for number in &number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {largest}");

    let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let mut largest = &number_list[0];

    for number in &number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {largest}");
}

fn largest(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {result}");
    assert_eq!(*result, 100);

    let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let result = largest(&number_list);
    println!("The largest number is {result}");
    assert_eq!(*result, 6000);
}

fn largest_i32(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> &char {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("The largest number is {result}");
    assert_eq!(*result, 100);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {result}");
    assert_eq!(*result, 'y');
}```

</Listing>

`largest_i32` ফাংশনটি আমরা লিস্টিং ১০-৩ এ এক্সট্র্যাক্ট করেছিলাম, যা একটি স্লাইস থেকে সবচেয়ে বড় `i32` খুঁজে বের করে। `largest_char` ফাংশনটি একটি স্লাইস থেকে সবচেয়ে বড় `char` খুঁজে বের করে। দুটি ফাংশনের বডি একই কোড ধারণ করে, তাই আসুন একটি জেনেরিক টাইপ প্যারামিটার ব্যবহার করে একটি একক ফাংশন তৈরি করে এই পুনরাবৃত্তি দূর করি।

একটি নতুন একক ফাংশনে টাইপগুলোকে প্যারামিটারাইজ করার জন্য, আমাদের টাইপ প্যারামিটারের একটি নাম দিতে হবে, ঠিক যেমন আমরা একটি ফাংশনের ভ্যালু প্যারামিটারের জন্য নাম দিই। আপনি টাইপ প্যারামিটারের নাম হিসেবে যেকোনো আইডেন্টিফায়ার ব্যবহার করতে পারেন। কিন্তু আমরা `T` ব্যবহার করব কারণ, প্রথা অনুযায়ী, Rust-এ টাইপ প্যারামিটারের নাম ছোট হয়, প্রায়শই কেবল একটি অক্ষর, এবং Rust-এর টাইপ-নামকরণের প্রথা হলো CamelCase। _type_-এর সংক্ষিপ্ত রূপ হিসেবে `T` বেশিরভাগ Rust প্রোগ্রামারদের প্রথম পছন্দ।

যখন আমরা ফাংশনের বডিতে একটি প্যারামিটার ব্যবহার করি, তখন আমাদের সিগনেচারে প্যারামিটারের নামটি ডিক্লেয়ার করতে হয় যাতে কম্পাইলার জানে সেই নামের অর্থ কী। একইভাবে, যখন আমরা একটি ফাংশন সিগনেচারে একটি টাইপ প্যারামিটারের নাম ব্যবহার করি, তখন ব্যবহারের আগে আমাদের টাইপ প্যারামিটারের নামটি ডিক্লেয়ার করতে হয়। জেনেরিক `largest` ফাংশনটি ডিফাইন করতে, আমরা ফাংশনের নাম এবং প্যারামিটার তালিকার মধ্যে অ্যাঙ্গেল ব্র্যাকেট `<>`-এর ভিতরে টাইপের নাম ডিক্লেয়ার করি, এভাবে:

```rust,ignore
fn largest<T>(list: &[T]) -> &T {

এই ডেফিনিশনটিকে আমরা এভাবে পড়ি: largest ফাংশনটি কোনো একটি টাইপ T-এর উপর জেনেরিক। এই ফাংশনের list নামে একটি প্যারামিটার আছে, যা T টাইপের ভ্যালুগুলোর একটি স্লাইস। largest ফাংশনটি একই টাইপ T-এর একটি ভ্যালুর রেফারেন্স রিটার্ন করবে।

লিস্টিং ১০-৫ এ জেনেরিক ডেটা টাইপ ব্যবহার করে সম্মিলিত largest ফাংশনের ডেফিনিশন দেখানো হয়েছে। লিস্টিংটি আরও দেখায় যে আমরা কীভাবে i32 মানের স্লাইস বা char মানের স্লাইস দিয়ে ফাংশনটি কল করতে পারি। মনে রাখবেন যে এই কোডটি এখনও কম্পাইল হবে না।

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {result}");
}

যদি আমরা এই কোডটি এখনই কম্পাইল করি, আমরা এই এররটি পাব:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `&T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- &T
  |            |
  |            &T
  |
help: consider restricting type parameter `T` with trait `PartialOrd`
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
  |             ++++++++++++++++++++++

For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

হেল্প টেক্সট-এ std::cmp::PartialOrd-এর কথা উল্লেখ করা হয়েছে, যা একটি trait, এবং আমরা পরবর্তী সেকশনে traits নিয়ে কথা বলব। আপাতত, জেনে রাখুন যে এই এররটি বলছে যে largest ফাংশনের বডি T-এর সম্ভাব্য সকল টাইপের জন্য কাজ করবে না। যেহেতু আমরা বডিতে T টাইপের মান তুলনা করতে চাই, তাই আমরা কেবল সেই টাইপগুলো ব্যবহার করতে পারি যাদের মান வரிசை অনুযায়ী সাজানো (ordered) যায়। তুলনা সক্রিয় করার জন্য, স্ট্যান্ডার্ড লাইব্রেরিতে std::cmp::PartialOrd trait রয়েছে যা আপনি টাইপগুলিতে ইমপ্লিমেন্ট করতে পারেন (এই trait সম্পর্কে আরও জানতে Appendix C দেখুন)। লিস্টিং ১০-৫ ঠিক করার জন্য, আমরা হেল্প টেক্সট-এর পরামর্শ অনুসরণ করতে পারি এবং T-এর জন্য বৈধ টাইপগুলোকে কেবল তাদের মধ্যে সীমাবদ্ধ রাখতে পারি যারা PartialOrd ইমপ্লিমেন্ট করে। এরপর লিস্টিংটি কম্পাইল হবে, কারণ স্ট্যান্ডার্ড লাইব্রেরি i32 এবং char উভয়ের উপরেই PartialOrd ইমপ্লিমেন্ট করে।

Struct ডেফিনিশনে

আমরা <> সিনট্যাক্স ব্যবহার করে এক বা একাধিক ফিল্ডে জেনেরিক টাইপ প্যারামিটার ব্যবহার করার জন্য struct ডিফাইন করতে পারি। লিস্টিং ১০-৬ একটি Point<T> struct ডিফাইন করে যা যেকোনো টাইপের x এবং y কো-অর্ডিনেট ভ্যালু ধারণ করে।

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

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

struct ডেফিনিশনে generics ব্যবহারের সিনট্যাক্স ফাংশন ডেফিনিশনে ব্যবহারের মতোই। প্রথমে আমরা struct-এর নামের ঠিক পরে অ্যাঙ্গেল ব্র্যাকেটের মধ্যে টাইপ প্যারামিটারের নাম ডিক্লেয়ার করি। তারপর আমরা struct ডেফিনিশনের মধ্যে জেনেরিক টাইপ ব্যবহার করি যেখানে আমরা অন্যথায় concrete ডেটা টাইপ নির্দিষ্ট করতাম।

মনে রাখবেন যে আমরা Point<T> ডিফাইন করতে কেবল একটি জেনেরিক টাইপ ব্যবহার করেছি, তাই এই ডেফিনিশনটি বলে যে Point<T> struct-টি কোনো একটি টাইপ T-এর উপর জেনেরিক, এবং x ও y ফিল্ড দুটি উভয়ই সেই একই টাইপের, টাইপটি যা-ই হোক না কেন। যদি আমরা ভিন্ন টাইপের মান দিয়ে একটি Point<T>-এর ইনস্ট্যান্স তৈরি করি, যেমন লিস্টিং ১০-৭-এ, আমাদের কোড কম্পাইল হবে না।

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

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

এই উদাহরণে, যখন আমরা x-কে ইন্টিজার ভ্যালু 5 অ্যাসাইন করি, তখন আমরা কম্পাইলারকে জানাই যে Point<T>-এর এই ইনস্ট্যান্সের জন্য জেনেরিক টাইপ T একটি ইন্টিজার হবে। তারপর যখন আমরা y-এর জন্য 4.0 নির্দিষ্ট করি, যা আমরা x-এর মতো একই টাইপের হিসেবে ডিফাইন করেছি, তখন আমরা একটি টাইপ মিসম্যাচ এরর পাব, যেমন:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
 --> src/main.rs:7:38
  |
7 |     let wont_work = Point { x: 5, y: 4.0 };
  |                                      ^^^ expected integer, found floating-point number

For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

x এবং y উভয়ই জেনেরিক কিন্তু ভিন্ন টাইপের হতে পারে এমন একটি Point struct ডিফাইন করতে, আমরা একাধিক জেনেরিক টাইপ প্যারামিটার ব্যবহার করতে পারি। উদাহরণস্বরূপ, লিস্টিং ১০-৮-এ, আমরা Point-এর ডেফিনিশন পরিবর্তন করে T এবং U দুটি টাইপের উপর জেনেরিক করেছি, যেখানে x-এর টাইপ T এবং y-এর টাইপ U।

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

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

এখন দেখানো Point-এর সমস্ত ইনস্ট্যান্স অনুমোদিত! আপনি একটি ডেফিনিশনে যত খুশি জেনেরিক টাইপ প্যারামিটার ব্যবহার করতে পারেন, তবে অল্প কয়েকটির বেশি ব্যবহার করলে আপনার কোড পড়া কঠিন হয়ে যায়। যদি আপনার কোডে অনেক জেনেরিক টাইপের প্রয়োজন হয়, তবে এটি ইঙ্গিত দিতে পারে যে আপনার কোডকে ছোট ছোট অংশে পুনর্গঠন করা প্রয়োজন।

Enum ডেফিনিশনে

যেমনটি আমরা struct-এর সাথে করেছি, আমরা enum-কেও তাদের ভ্যারিয়েন্টে জেনেরিক ডেটা টাইপ ধারণ করার জন্য ডিফাইন করতে পারি। আসুন আমরা স্ট্যান্ডার্ড লাইব্রেরির দেওয়া Option<T> enum-টি আবার দেখি, যা আমরা চ্যাপ্টার ৬-এ ব্যবহার করেছি:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

এই ডেফিনিশনটি এখন আপনার কাছে আরও বেশি অর্থবহ মনে হওয়া উচিত। जैसा कि आप देख सकते हैं, Option<T> enum টি T টাইপের উপর জেনেরিক এবং এর দুটি ভ্যারিয়েন্ট রয়েছে: Some, যা T টাইপের একটি মান ধারণ করে, এবং None ভ্যারিয়েন্ট যা কোনো মান ধারণ করে না। Option<T> enum ব্যবহার করে, আমরা একটি ঐচ্ছিক মানের অ্যাবস্ট্রাক্ট ধারণা প্রকাশ করতে পারি, এবং যেহেতু Option<T> জেনেরিক, তাই ঐচ্ছিক মানের টাইপ যা-ই হোক না কেন, আমরা এই অ্যাবস্ট্রাকশনটি ব্যবহার করতে পারি।

Enum একাধিক জেনেরিক টাইপও ব্যবহার করতে পারে। Result enum-এর ডেফিনিশন, যা আমরা চ্যাপ্টার ৯-এ ব্যবহার করেছি, এর একটি উদাহরণ:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Result enum-টি T এবং E দুটি টাইপের উপর জেনেরিক, এবং এর দুটি ভ্যারিয়েন্ট রয়েছে: Ok, যা T টাইপের একটি মান ধারণ করে, এবং Err, যা E টাইপের একটি মান ধারণ করে। এই ডেফিনিশনটি Result enum ব্যবহার করা সুবিধাজনক করে তোলে যেখানেই আমাদের এমন কোনো অপারেশন থাকে যা সফল হতে পারে (T টাইপের কোনো মান রিটার্ন করে) বা ব্যর্থ হতে পারে (E টাইপের কোনো এরর রিটার্ন করে)। প্রকৃতপক্ষে, এটিই আমরা লিস্টিং ৯-৩-এ একটি ফাইল খোলার জন্য ব্যবহার করেছিলাম, যেখানে ফাইলটি সফলভাবে খোলা হলে T-কে std::fs::File টাইপ দিয়ে পূরণ করা হয়েছিল এবং ফাইল খুলতে সমস্যা হলে E-কে std::io::Error টাইপ দিয়ে পূরণ করা হয়েছিল।

যখন আপনি আপনার কোডে এমন পরিস্থিতি শনাক্ত করেন যেখানে একাধিক struct বা enum ডেফিনিশন রয়েছে যা কেবল তাদের ধারণ করা মানের টাইপের দিক থেকে ভিন্ন, তখন আপনি জেনেরিক টাইপ ব্যবহার করে পুনরাবৃত্তি এড়াতে পারেন।

মেথড ডেফিনিশনে

আমরা struct এবং enum-এর উপর মেথড ইমপ্লিমেন্ট করতে পারি (যেমনটি আমরা চ্যাপ্টার ৫-এ করেছি) এবং তাদের ডেফিনিশনেও জেনেরিক টাইপ ব্যবহার করতে পারি। লিস্টিং ১০-৯-এ আমরা লিস্টিং ১০-৬-এ ডিফাইন করা Point<T> struct-টি দেখাচ্ছি, যার উপর x নামের একটি মেথড ইমপ্লিমেন্ট করা হয়েছে।

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

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

এখানে, আমরা Point<T>-এর উপর x নামের একটি মেথড ডিফাইন করেছি যা x ফিল্ডের ডেটার একটি রেফারেন্স রিটার্ন করে।

লক্ষ্য করুন যে, impl-এর ঠিক পরেই আমাদের T ডিক্লেয়ার করতে হবে যাতে আমরা Point<T> টাইপের উপর মেথড ইমপ্লিমেন্ট করছি তা নির্দিষ্ট করতে T ব্যবহার করতে পারি। impl-এর পরে T-কে একটি জেনেরিক টাইপ হিসেবে ডিক্লেয়ার করার মাধ্যমে, Rust শনাক্ত করতে পারে যে Point-এর অ্যাঙ্গেল ব্র্যাকেটের মধ্যে থাকা টাইপটি একটি জেনেরিক টাইপ, কোনো concrete টাইপ নয়। আমরা struct ডেফিনিশনে ডিক্লেয়ার করা জেনেরিক প্যারামিটারের চেয়ে এই জেনেরিক প্যারামিটারের জন্য একটি ভিন্ন নাম বেছে নিতে পারতাম, কিন্তু একই নাম ব্যবহার করাই প্রচলিত। যদি আপনি একটি জেনেরিক টাইপ ডিক্লেয়ার করে এমন একটি impl-এর মধ্যে একটি মেথড লেখেন, তবে সেই মেথডটি টাইপের যেকোনো ইনস্ট্যান্সের উপর ডিফাইন করা হবে, জেনেরিক টাইপের পরিবর্তে যে কোনো concrete টাইপই আসুক না কেন।

আমরা টাইপের উপর মেথড ডিফাইন করার সময় জেনেরিক টাইপের উপর সীমাবদ্ধতাও নির্দিষ্ট করতে পারি। উদাহরণস্বরূপ, আমরা যেকোনো জেনেরিক টাইপের Point<T> ইনস্ট্যান্সের পরিবর্তে শুধুমাত্র Point<f32> ইনস্ট্যান্সের উপর মেথড ইমপ্লিমেন্ট করতে পারি। লিস্টিং ১০-১০-এ আমরা concrete টাইপ f32 ব্যবহার করি, যার মানে আমরা impl-এর পরে কোনো টাইপ ডিক্লেয়ার করি না।

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

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

এই কোডের মানে হলো Point<f32> টাইপের একটি distance_from_origin মেথড থাকবে; Point<T>-এর অন্যান্য ইনস্ট্যান্স যেখানে T f32 টাইপের নয়, তাদের এই মেথডটি ডিফাইন করা থাকবে না। মেথডটি আমাদের পয়েন্টটি (0.0, 0.0) কো-অর্ডিনেটের পয়েন্ট থেকে কত দূরে তা পরিমাপ করে এবং গাণিতিক অপারেশন ব্যবহার করে যা শুধুমাত্র ফ্লোটিং-পয়েন্ট টাইপের জন্য উপলব্ধ।

একটি struct ডেফিনিশনের জেনেরিক টাইপ প্যারামিটার সবসময় সেই একই struct-এর মেথড সিগনেচারে ব্যবহার করা প্যারামিটারের মতো হয় না। লিস্টিং ১০-১১ উদাহরণটিকে আরও স্পষ্ট করার জন্য Point struct-এর জন্য X1 এবং Y1 এবং mixup মেথড সিগনেচারের জন্য X2 Y2 জেনেরিক টাইপ ব্যবহার করে। মেথডটি self Point (যার টাইপ X1) থেকে x ভ্যালু এবং পাস করা Point (যার টাইপ Y2) থেকে y ভ্যালু নিয়ে একটি নতুন Point ইনস্ট্যান্স তৈরি করে।

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

main ফাংশনে, আমরা একটি Point ডিফাইন করেছি যার x-এর জন্য একটি i32 (মান 5) এবং y-এর জন্য একটি f64 (মান 10.4) রয়েছে। p2 ভ্যারিয়েবলটি একটি Point struct যার x-এর জন্য একটি স্ট্রিং স্লাইস (মান "Hello") এবং y-এর জন্য একটি char (মান c) রয়েছে। p1-এর উপর p2 আর্গুমেন্ট দিয়ে mixup কল করলে আমরা p3 পাই, যার x-এর জন্য একটি i32 থাকবে কারণ x p1 থেকে এসেছে। p3 ভ্যারিয়েবলের y-এর জন্য একটি char থাকবে কারণ y p2 থেকে এসেছে। println! ম্যাক্রো কলটি p3.x = 5, p3.y = c প্রিন্ট করবে।

এই উদাহরণের উদ্দেশ্য হলো এমন একটি পরিস্থিতি প্রদর্শন করা যেখানে কিছু জেনেরিক প্যারামিটার impl-এর সাথে এবং কিছু মেথড ডেফিনিশনের সাথে ডিক্লেয়ার করা হয়। এখানে, জেনেরিক প্যারামিটার X1 এবং Y1 impl-এর পরে ডিক্লেয়ার করা হয়েছে কারণ তারা struct ডেফিনিশনের সাথে যায়। জেনেরিক প্যারামিটার X2 এবং Y2 fn mixup-এর পরে ডিক্লেয়ার করা হয়েছে কারণ তারা কেবল মেথডের জন্য প্রাসঙ্গিক।

Generics ব্যবহার করা কোডের পারফরম্যান্স

আপনি হয়তো ভাবছেন যে জেনেরিক টাইপ প্যারামিটার ব্যবহার করার সময় কোনো রানটাইম খরচ আছে কিনা। সুখবর হলো যে জেনেরিক টাইপ ব্যবহার করলে আপনার প্রোগ্রামটি concrete টাইপ ব্যবহার করার চেয়ে কোনো ধীর গতিতে চলবে না।

Rust কম্পাইল টাইমে generics ব্যবহার করা কোডের মনোমর্ফাইজেশন (monomorphization) সম্পাদন করে এটি অর্জন করে। Monomorphization হলো কম্পাইল টাইমে ব্যবহৃত concrete টাইপগুলো দিয়ে জেনেরিক কোডকে নির্দিষ্ট কোডে পরিণত করার প্রক্রিয়া। এই প্রক্রিয়ায়, কম্পাইলার আমরা লিস্টিং ১০-৫-এ জেনেরিক ফাংশন তৈরি করার জন্য যে পদক্ষেপগুলো ব্যবহার করেছি তার বিপরীত কাজ করে: কম্পাইলার সেই সমস্ত জায়গা দেখে যেখানে জেনেরিক কোড কল করা হয়েছে এবং যে concrete টাইপ দিয়ে জেনেরিক কোড কল করা হয়েছে তার জন্য কোড তৈরি করে।

আসুন দেখি এটি কীভাবে কাজ করে স্ট্যান্ডার্ড লাইব্রেরির জেনেরিক Option<T> enum ব্যবহার করে:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

যখন Rust এই কোডটি কম্পাইল করে, তখন এটি মনোমর্ফাইজেশন সম্পাদন করে। সেই প্রক্রিয়ার সময়, কম্পাইলার Option<T> ইনস্ট্যান্সে ব্যবহৃত মানগুলো পড়ে এবং দুই ধরণের Option<T> শনাক্ত করে: একটি i32 এবং অন্যটি f64। ফলস্বরূপ, এটি Option<T>-এর জেনেরিক ডেফিনিশনকে i32 এবং f64-এর জন্য বিশেষায়িত দুটি ডেফিনিশনে প্রসারিত করে, যার ফলে জেনেরিক ডেফিনিশনটিকে নির্দিষ্টগুলো দিয়ে প্রতিস্থাপন করে।

কোডের মনোমর্ফাইজড সংস্করণটি নিচের মতো দেখতে (কম্পাইলার এখানে উদাহরণের জন্য আমরা যে নামগুলো ব্যবহার করছি তার চেয়ে ভিন্ন নাম ব্যবহার করে):

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

জেনেরিক Option<T> কম্পাইলার দ্বারা তৈরি করা নির্দিষ্ট ডেফিনিশন দিয়ে প্রতিস্থাপিত হয়। কারণ Rust জেনেরিক কোডকে এমন কোডে কম্পাইল করে যা প্রতিটি ইনস্ট্যান্সে টাইপ নির্দিষ্ট করে, তাই generics ব্যবহারের জন্য আমাদের কোনো রানটাইম খরচ দিতে হয় না। কোডটি যখন চলে, তখন এটি ঠিক তেমনই পারফর্ম করে যেমনটি আমরা প্রতিটি ডেফিনিশন হাতে হাতে ডুপ্লিকেট করলে করত। মনোমর্ফাইজেশন প্রক্রিয়াটি রানটাইমে Rust-এর generics-কে অত্যন্ত কার্যকরী করে তোলে।

ট্রেইট (Traits): সাধারণ আচরণ ডিফাইন করা

একটি trait কোনো নির্দিষ্ট টাইপের কার্যকারিতা (functionality) ডিফাইন করে যা অন্যান্য টাইপের সাথে শেয়ার করা যায়। আমরা অ্যাবস্ট্রাক্ট উপায়ে সাধারণ আচরণ (shared behavior) ডিফাইন করতে traits ব্যবহার করতে পারি। আমরা trait bounds ব্যবহার করে নির্দিষ্ট করতে পারি যে একটি জেনেরিক টাইপ যেকোনো টাইপের হতে পারে, যতক্ষণ পর্যন্ত তার একটি নির্দিষ্ট আচরণ থাকে।

দ্রষ্টব্য: Traits অন্যান্য ভাষার interfaces নামক একটি ফিচারের মতো, যদিও কিছু পার্থক্য রয়েছে।

একটি ট্রেইট ডিফাইন করা

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

উদাহরণস্বরূপ, ধরা যাক আমাদের একাধিক struct আছে যা বিভিন্ন ধরনের এবং পরিমাণের টেক্সট ধারণ করে: একটি NewsArticle struct যা একটি নির্দিষ্ট অবস্থানে ফাইল করা সংবাদ ধরে রাখে এবং একটি SocialPost যা সর্বোচ্চ ২৮০ অক্ষর ধারণ করতে পারে, সাথে মেটাডেটা যা নির্দেশ করে এটি একটি নতুন পোস্ট, একটি রিপোস্ট, বা অন্য কোনো পোস্টের উত্তর ছিল কিনা।

আমরা aggregator নামে একটি মিডিয়া অ্যাগ্রিগেটর লাইব্রেরি ক্রেট তৈরি করতে চাই যা NewsArticle বা SocialPost ইনস্ট্যান্সে সংরক্ষিত ডেটার সারাংশ প্রদর্শন করতে পারে। এটি করার জন্য, আমাদের প্রতিটি টাইপ থেকে একটি সারাংশ প্রয়োজন, এবং আমরা একটি ইনস্ট্যান্সের উপর summarize মেথড কল করে সেই সারাংশটি অনুরোধ করব। লিস্টিং ১০-১২ একটি পাবলিক Summary trait-এর ডেফিনিশন দেখায় যা এই আচরণটি প্রকাশ করে।

pub trait Summary {
    fn summarize(&self) -> String;
}

এখানে, আমরা trait কিওয়ার্ড ব্যবহার করে একটি trait ডিক্লেয়ার করি এবং তারপর trait-এর নাম, যা এই ক্ষেত্রে Summary। আমরা trait-টিকে pub হিসেবেও ডিক্লেয়ার করি যাতে এই ক্রেটের উপর নির্ভরশীল ক্রেটগুলোও এই trait ব্যবহার করতে পারে, যেমনটি আমরা কয়েকটি উদাহরণে দেখব। কার্লি ব্র্যাকেটের ভিতরে, আমরা মেথড সিগনেচারগুলো ডিক্লেয়ার করি যা এই trait ইমপ্লিমেন্ট করা টাইপগুলোর আচরণ বর্ণনা করে, যা এই ক্ষেত্রে fn summarize(&self) -> String।

মেথড সিগনেচারের পরে, কার্লি ব্র্যাকেটের মধ্যে একটি ইমপ্লিমেন্টেশন প্রদান করার পরিবর্তে, আমরা একটি সেমিকোলন ব্যবহার করি। এই trait ইমপ্লিমেন্ট করা প্রতিটি টাইপকে অবশ্যই মেথডের বডির জন্য নিজস্ব কাস্টম আচরণ প্রদান করতে হবে। কম্পাইলার নিশ্চিত করবে যে Summary trait যুক্ত যেকোনো টাইপের summarize মেথডটি ঠিক এই সিগনেচার দিয়ে ডিফাইন করা থাকবে।

একটি trait-এর বডিতে একাধিক মেথড থাকতে পারে: মেথড সিগনেচারগুলো প্রতি লাইনে একটি করে তালিকাভুক্ত করা হয় এবং প্রতিটি লাইন একটি সেমিকোলন দিয়ে শেষ হয়।

একটি টাইপের উপর ট্রেইট ইমপ্লিমেন্ট করা

এখন যেহেতু আমরা Summary trait-এর মেথডগুলোর কাঙ্ক্ষিত সিগনেচার ডিফাইন করেছি, আমরা এটিকে আমাদের মিডিয়া অ্যাগ্রিগেটরের টাইপগুলোতে ইমপ্লিমেন্ট করতে পারি। লিস্টিং ১০-১৩ NewsArticle struct-এর উপর Summary trait-এর একটি ইমপ্লিমেন্টেশন দেখায় যা summarize-এর রিটার্ন ভ্যালু তৈরি করতে হেডলাইন, লেখক এবং অবস্থান ব্যবহার করে। SocialPost struct-এর জন্য, আমরা summarize-কে ইউজারের নাম এবং পোস্টের সম্পূর্ণ টেক্সট হিসেবে ডিফাইন করি, এই ধরে নিয়ে যে পোস্টের বিষয়বস্তু ইতিমধ্যে ২৮০ অক্ষরের মধ্যে সীমাবদ্ধ।

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

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

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

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

একটি টাইপের উপর একটি trait ইমপ্লিমেন্ট করা সাধারণ মেথড ইমপ্লিমেন্ট করার মতোই। পার্থক্য হলো impl-এর পরে, আমরা যে trait-টি ইমপ্লিমেন্ট করতে চাই তার নাম লিখি, তারপর for কিওয়ার্ড ব্যবহার করি এবং তারপর যে টাইপের জন্য trait-টি ইমপ্লিমেন্ট করতে চাই তার নাম নির্দিষ্ট করি। impl ব্লকের মধ্যে, আমরা trait ডেফিনিশনে সংজ্ঞায়িত মেথড সিগনেচারগুলো রাখি। প্রতিটি সিগনেচারের পরে সেমিকোলন যোগ করার পরিবর্তে, আমরা কার্লি ব্র্যাকেট ব্যবহার করি এবং নির্দিষ্ট টাইপের জন্য trait-এর মেথডগুলোর যে নির্দিষ্ট আচরণ আমরা চাই তা দিয়ে মেথড বডি পূরণ করি।

এখন যেহেতু লাইব্রেরিটি NewsArticle এবং SocialPost-এর উপর Summary trait ইমপ্লিমেন্ট করেছে, ক্রেটের ব্যবহারকারীরা NewsArticle এবং SocialPost-এর ইনস্ট্যান্সের উপর trait মেথডগুলো কল করতে পারবে ঠিক যেভাবে আমরা সাধারণ মেথড কল করি। একমাত্র পার্থক্য হলো ব্যবহারকারীকে অবশ্যই trait এবং টাইপ উভয়কেই স্কোপে আনতে হবে। এখানে একটি উদাহরণ দেওয়া হলো যে কীভাবে একটি বাইনারি ক্রেট আমাদের aggregator লাইব্রেরি ক্রেট ব্যবহার করতে পারে:

use aggregator::{SocialPost, Summary};

fn main() {
    let post = SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    };

    println!("1 new post: {}", post.summarize());
}

এই কোডটি প্রিন্ট করে 1 new post: horse_ebooks: of course, as you probably already know, people।

aggregator ক্রেটের উপর নির্ভরশীল অন্যান্য ক্রেটগুলোও তাদের নিজস্ব টাইপের উপর Summary ইমপ্লিমেন্ট করার জন্য Summary trait-টিকে স্কোপে আনতে পারে। একটি সীমাবদ্ধতা মনে রাখতে হবে যে আমরা একটি টাইপের উপর একটি trait শুধুমাত্র তখনই ইমপ্লিমেন্ট করতে পারি যদি trait অথবা টাইপ, বা উভয়ই, আমাদের ক্রেটের জন্য লোকাল (local) হয়। উদাহরণস্বরূপ, আমরা আমাদের aggregator ক্রেটের কার্যকারিতার অংশ হিসেবে SocialPost-এর মতো একটি কাস্টম টাইপের উপর Display-এর মতো স্ট্যান্ডার্ড লাইব্রেরি trait ইমপ্লিমেন্ট করতে পারি কারণ SocialPost টাইপটি আমাদের aggregator ক্রেটের জন্য লোকাল। আমরা আমাদের aggregator ক্রেটে Vec<T>-এর উপর Summary ইমপ্লিমেন্ট করতে পারি কারণ Summary trait-টি আমাদের aggregator ক্রেটের জন্য লোকাল।

কিন্তু আমরা এক্সটার্নাল টাইপের উপর এক্সটার্নাল trait ইমপ্লিমেন্ট করতে পারি না। উদাহরণস্বরূপ, আমরা আমাদের aggregator ক্রেটের মধ্যে Vec<T>-এর উপর Display trait ইমপ্লিমেন্ট করতে পারি না কারণ Display এবং Vec<T> উভয়ই স্ট্যান্ডার্ড লাইব্রেরিতে ডিফাইন করা এবং আমাদের aggregator ক্রেটের জন্য লোকাল নয়। এই সীমাবদ্ধতাটি coherence নামক একটি বৈশিষ্ট্যের অংশ, এবং আরও নির্দিষ্টভাবে orphan rule নামে পরিচিত, কারণ প্যারেন্ট টাইপ উপস্থিত নেই। এই নিয়মটি নিশ্চিত করে যে অন্য লোকের কোড আপনার কোড ভাঙতে পারবে না এবং বিপরীতক্রমেও। এই নিয়ম ছাড়া, দুটি ক্রেট একই টাইপের জন্য একই trait ইমপ্লিমেন্ট করতে পারত, এবং Rust জানত না কোন ইমপ্লিমেন্টেশনটি ব্যবহার করতে হবে।

ডিফল্ট ইমপ্লিমেন্টেশন (Default Implementations)

কখনও কখনও একটি trait-এর কিছু বা সমস্ত মেথডের জন্য ডিফল্ট আচরণ থাকা দরকারী, প্রতিটি টাইপের উপর সমস্ত মেথডের জন্য ইমপ্লিমেন্টেশন দাবি করার পরিবর্তে। তারপর, যখন আমরা কোনো নির্দিষ্ট টাইপের উপর trait-টি ইমপ্লিমেন্ট করি, তখন আমরা প্রতিটি মেথডের ডিফল্ট আচরণ রাখতে বা ওভাররাইড করতে পারি।

লিস্টিং ১০-১৪-এ, আমরা Summary trait-এর summarize মেথডের জন্য একটি ডিফল্ট স্ট্রিং নির্দিষ্ট করি, শুধুমাত্র মেথড সিগনেচার ডিফাইন করার পরিবর্তে, যেমনটি আমরা লিস্টিং ১০-১২-এ করেছিলাম।

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {}

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

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

NewsArticle-এর ইনস্ট্যান্সগুলোর সারাংশ তৈরি করতে ডিফল্ট ইমপ্লিমেন্টেশন ব্যবহার করার জন্য, আমরা impl Summary for NewsArticle {} দিয়ে একটি খালি impl ব্লক নির্দিষ্ট করি।

যদিও আমরা আর সরাসরি NewsArticle-এ summarize মেথড ডিফাইন করছি না, আমরা একটি ডিফল্ট ইমপ্লিমেন্টেশন সরবরাহ করেছি এবং নির্দিষ্ট করেছি যে NewsArticle Summary trait ইমপ্লিমেন্ট করে। ফলস্বরূপ, আমরা এখনও একটি NewsArticle-এর ইনস্ট্যান্সে summarize মেথড কল করতে পারি, এভাবে:

use aggregator::{self, NewsArticle, Summary};

fn main() {
    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from(
            "The Pittsburgh Penguins once again are the best \
             hockey team in the NHL.",
        ),
    };

    println!("New article available! {}", article.summarize());
}

এই কোডটি New article available! (Read more...) প্রিন্ট করে।

একটি ডিফল্ট ইমপ্লিমেন্টেশন তৈরি করার জন্য লিস্টিং ১০-১৩-এর SocialPost-এ Summary-এর ইমপ্লিমেন্টেশন সম্পর্কে আমাদের কিছু পরিবর্তন করতে হবে না। কারণটি হলো একটি ডিফল্ট ইমপ্লিমেন্টেশন ওভাররাইড করার সিনট্যাক্স এবং যে trait মেথডের ডিফল্ট ইমপ্লিমেন্টেশন নেই তা ইমপ্লিমেন্ট করার সিনট্যাক্স একই।

ডিফল্ট ইমপ্লিমেন্টেশনগুলো একই trait-এর অন্যান্য মেথড কল করতে পারে, এমনকি যদি সেই অন্যান্য মেথডগুলোর ডিফল্ট ইমপ্লিমেন্টেশন না থাকে। এইভাবে, একটি trait অনেক দরকারী কার্যকারিতা সরবরাহ করতে পারে এবং ইমপ্লিমেন্টরদের শুধুমাত্র একটি ছোট অংশ নির্দিষ্ট করতে হয়। উদাহরণস্বরূপ, আমরা Summary trait-কে এমনভাবে ডিফাইন করতে পারি যাতে একটি summarize_author মেথড থাকে যার ইমপ্লিমেন্টেশন আবশ্যক, এবং তারপর একটি summarize মেথড ডিফাইন করতে পারি যার একটি ডিফল্ট ইমপ্লিমেন্টেশন থাকে যা summarize_author মেথডকে কল করে:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

Summary-এর এই সংস্করণটি ব্যবহার করতে, আমাদের কেবল একটি টাইপের উপর trait ইমপ্লিমেন্ট করার সময় summarize_author ডিফাইন করতে হবে:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

আমরা summarize_author ডিফাইন করার পরে, আমরা SocialPost struct-এর ইনস্ট্যান্সগুলিতে summarize কল করতে পারি, এবং summarize-এর ডিফল্ট ইমপ্লিমেন্টেশনটি আমাদের সরবরাহ করা summarize_author-এর ডেফিনিশনকে কল করবে। যেহেতু আমরা summarize_author ইমপ্লিমেন্ট করেছি, Summary trait আমাদের summarize মেথডের আচরণ দিয়েছে কোনো অতিরিক্ত কোড লেখা ছাড়াই। এটি দেখতে এরকম:

use aggregator::{self, SocialPost, Summary};

fn main() {
    let post = SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    };

    println!("1 new post: {}", post.summarize());
}

এই কোডটি প্রিন্ট করে 1 new post: (Read more from @horse_ebooks...)।

মনে রাখবেন যে একই মেথডের একটি ওভাররাইডিং ইমপ্লিমেন্টেশন থেকে ডিফল্ট ইমপ্লিমেন্টেশন কল করা সম্ভব নয়।

প্যারামিটার হিসাবে ট্রেইট (Traits as Parameters)

এখন আপনি জানেন কিভাবে trait ডিফাইন এবং ইমপ্লিমেন্ট করতে হয়, আমরা এখন দেখব কিভাবে trait ব্যবহার করে এমন ফাংশন ডিফাইন করা যায় যা বিভিন্ন ধরনের টাইপ গ্রহণ করতে পারে। আমরা লিস্টিং ১০-১৩-এ NewsArticle এবং SocialPost টাইপের উপর ইমপ্লিমেন্ট করা Summary trait ব্যবহার করে একটি notify ফাংশন ডিফাইন করব যা তার item প্যারামিটারে summarize মেথড কল করে, যা এমন কোনো টাইপের যা Summary trait ইমপ্লিমেন্ট করে। এটি করার জন্য, আমরা impl Trait সিনট্যাক্স ব্যবহার করি, এভাবে:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

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

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

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

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

item প্যারামিটারের জন্য একটি concrete টাইপের পরিবর্তে, আমরা impl কিওয়ার্ড এবং trait-এর নাম নির্দিষ্ট করি। এই প্যারামিটারটি নির্দিষ্ট trait ইমপ্লিমেন্ট করে এমন যেকোনো টাইপ গ্রহণ করে। notify-এর বডিতে, আমরা item-এর উপর Summary trait থেকে আসা যেকোনো মেথড কল করতে পারি, যেমন summarize। আমরা notify কল করতে পারি এবং যেকোনো NewsArticle বা SocialPost-এর ইনস্ট্যান্স পাস করতে পারি। যে কোড String বা i32-এর মতো অন্য কোনো টাইপ দিয়ে ফাংশনটি কল করবে, তা কম্পাইল হবে না কারণ সেই টাইপগুলো Summary ইমপ্লিমেন্ট করে না।

ট্রেইট বাউন্ড সিনট্যাক্স (Trait Bound Syntax)

impl Trait সিনট্যাক্স সহজ ক্ষেত্রে কাজ করে তবে এটি আসলে একটি দীর্ঘ ফর্মের জন্য সিনট্যাক্স সুগার যা trait bound নামে পরিচিত; এটি দেখতে এইরকম:

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

এই দীর্ঘ ফর্মটি পূর্ববর্তী বিভাগের উদাহরণের সমতুল্য তবে আরও ভার্বোস। আমরা জেনেরিক টাইপ প্যারামিটারের ডিক্লেয়ারেশনের সাথে একটি কোলনের পরে এবং অ্যাঙ্গেল ব্র্যাকেটের ভিতরে trait bounds রাখি।

impl Trait সিনট্যাক্স সুবিধাজনক এবং সহজ ক্ষেত্রে কোডকে আরও সংক্ষিপ্ত করে তোলে, যেখানে সম্পূর্ণ trait bound সিনট্যাক্স অন্যান্য ক্ষেত্রে আরও জটিলতা প্রকাশ করতে পারে। উদাহরণস্বরূপ, আমাদের দুটি প্যারামিটার থাকতে পারে যা Summary ইমপ্লিমেন্ট করে। impl Trait সিনট্যাক্স দিয়ে এটি করতে হলে দেখতে এমন হবে:

pub fn notify(item1: &impl Summary, item2: &impl Summary) {

impl Trait ব্যবহার করা উপযুক্ত যদি আমরা এই ফাংশনটিকে item1 এবং item2-কে ভিন্ন টাইপের হতে দিতে চাই (যতক্ষণ উভয় টাইপ Summary ইমপ্লিমেন্ট করে)। যদি আমরা উভয় প্যারামিটারকে একই টাইপের হতে বাধ্য করতে চাই, তবে আমাদের অবশ্যই একটি trait bound ব্যবহার করতে হবে, যেমন:

pub fn notify<T: Summary>(item1: &T, item2: &T) {

item1 এবং item2 প্যারামিটারের টাইপ হিসাবে নির্দিষ্ট করা জেনেরিক টাইপ T ফাংশনটিকে এমনভাবে সীমাবদ্ধ করে যে item1 এবং item2-এর জন্য আর্গুমেন্ট হিসাবে পাস করা মানের concrete টাইপ অবশ্যই একই হতে হবে।

+ সিনট্যাক্স দিয়ে একাধিক ট্রেইট বাউন্ড নির্দিষ্ট করা

আমরা একাধিক trait bound-ও নির্দিষ্ট করতে পারি। ধরা যাক আমরা চাই notify item-এ summarize-এর পাশাপাশি ডিসপ্লে ফরম্যাটিংও ব্যবহার করুক: আমরা notify ডেফিনিশনে নির্দিষ্ট করি যে item অবশ্যই Display এবং Summary উভয়ই ইমপ্লিমেন্ট করবে। আমরা + সিনট্যাক্স ব্যবহার করে এটি করতে পারি:

pub fn notify(item: &(impl Summary + Display)) {

+ সিনট্যাক্স জেনেরিক টাইপের উপর trait bounds-এর সাথেও বৈধ:

pub fn notify<T: Summary + Display>(item: &T) {

দুটি trait bounds নির্দিষ্ট করার সাথে, notify-এর বডি summarize কল করতে পারে এবং item ফরম্যাট করতে {} ব্যবহার করতে পারে।

where ক্লজ দিয়ে পরিষ্কার ট্রেইট বাউন্ড

অতিরিক্ত trait bounds ব্যবহার করার কিছু অসুবিধা আছে। প্রতিটি জেনেরিকের নিজস্ব trait bounds থাকে, তাই একাধিক জেনেরিক টাইপ প্যারামিটারযুক্ত ফাংশনগুলোতে ফাংশনের নাম এবং তার প্যারামিটার তালিকার মধ্যে প্রচুর trait bound তথ্য থাকতে পারে, যা ফাংশন সিগনেচার পড়া কঠিন করে তোলে। এই কারণে, Rust-এর ফাংশন সিগনেচারের পরে একটি where ক্লজের ভিতরে trait bounds নির্দিষ্ট করার জন্য বিকল্প সিনট্যাক্স রয়েছে। সুতরাং, এটি লেখার পরিবর্তে:

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

আমরা একটি where ক্লজ ব্যবহার করতে পারি, এভাবে:

fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    unimplemented!()
}

এই ফাংশনের সিগনেচারটি কম জটীল: ফাংশনের নাম, প্যারামিটার তালিকা এবং রিটার্ন টাইপ কাছাকাছি রয়েছে, অনেকটা trait bounds ছাড়া একটি ফাংশনের মতো।

ট্রেইট ইমপ্লিমেন্ট করে এমন টাইপ রিটার্ন করা

আমরা রিটার্ন পজিশনে impl Trait সিনট্যাক্স ব্যবহার করে এমন একটি টাইপের মান রিটার্ন করতে পারি যা একটি trait ইমপ্লিমেন্ট করে, যেমনটি এখানে দেখানো হয়েছে:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

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

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

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

fn returns_summarizable() -> impl Summary {
    SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    }
}

রিটার্ন টাইপের জন্য impl Summary ব্যবহার করে, আমরা নির্দিষ্ট করি যে returns_summarizable ফাংশনটি Summary trait ইমপ্লিমেন্ট করে এমন কোনো টাইপ রিটার্ন করে, concrete টাইপের নাম উল্লেখ না করেই। এই ক্ষেত্রে, returns_summarizable একটি SocialPost রিটার্ন করে, কিন্তু এই ফাংশন কল করা কোডকে এটি জানার প্রয়োজন নেই।

শুধুমাত্র যে trait ইমপ্লিমেন্ট করে তা দ্বারা একটি রিটার্ন টাইপ নির্দিষ্ট করার ক্ষমতাটি ক্লোজার এবং ইটারেটরের প্রসঙ্গে বিশেষভাবে কার্যকর, যা আমরা চ্যাপ্টার ১৩-এ আলোচনা করব। ক্লোজার এবং ইটারেটর এমন টাইপ তৈরি করে যা কেবল কম্পাইলার জানে বা যে টাইপগুলো নির্দিষ্ট করা খুব দীর্ঘ। impl Trait সিনট্যাক্স আপনাকে সংক্ষিপ্তভাবে নির্দিষ্ট করতে দেয় যে একটি ফাংশন Iterator trait ইমপ্লিমেন্ট করে এমন কোনো টাইপ রিটার্ন করে, একটি খুব দীর্ঘ টাইপ লেখার প্রয়োজন ছাড়াই।

তবে, আপনি কেবল impl Trait ব্যবহার করতে পারেন যদি আপনি একটি একক টাইপ রিটার্ন করেন। উদাহরণস্বরূপ, এই কোডটি যা impl Summary হিসাবে রিটার্ন টাইপ নির্দিষ্ট করে একটি NewsArticle বা একটি SocialPost রিটার্ন করে, কাজ করবে না:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

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

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

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

fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        NewsArticle {
            headline: String::from(
                "Penguins win the Stanley Cup Championship!",
            ),
            location: String::from("Pittsburgh, PA, USA"),
            author: String::from("Iceburgh"),
            content: String::from(
                "The Pittsburgh Penguins once again are the best \
                 hockey team in the NHL.",
            ),
        }
    } else {
        SocialPost {
            username: String::from("horse_ebooks"),
            content: String::from(
                "of course, as you probably already know, people",
            ),
            reply: false,
            repost: false,
        }
    }
}

কম্পাইলারে impl Trait সিনট্যাক্স কীভাবে ইমপ্লিমেন্ট করা হয়েছে তার সীমাবদ্ধতার কারণে একটি NewsArticle বা একটি SocialPost রিটার্ন করা অনুমোদিত নয়। আমরা চ্যাপ্টার ১৮-এর “ভিন্ন ধরনের মানের জন্য ট্রেইট অবজেক্ট ব্যবহার করা” বিভাগে এই আচরণ সহ একটি ফাংশন কীভাবে লিখতে হয় তা আলোচনা করব।

ট্রেইট বাউন্ড ব্যবহার করে শর্তসাপেক্ষে মেথড ইমপ্লিমেন্ট করা

জেনেরিক টাইপ প্যারামিটার ব্যবহার করে একটি impl ব্লকের সাথে একটি trait bound ব্যবহার করে, আমরা নির্দিষ্ট trait ইমপ্লিমেন্ট করে এমন টাইপগুলোর জন্য শর্তসাপেক্ষে মেথড ইমপ্লিমেন্ট করতে পারি। উদাহরণস্বরূপ, লিস্টিং ১০-১৫-এর Pair<T> টাইপটি সর্বদা Pair<T>-এর একটি নতুন ইনস্ট্যান্স রিটার্ন করার জন্য new ফাংশন ইমপ্লিমেন্ট করে (চ্যাপ্টার ৫-এর “মেথড ডিফাইন করা” বিভাগ থেকে মনে করুন যে Self হলো impl ব্লকের টাইপের একটি টাইপ অ্যালিয়াস, যা এই ক্ষেত্রে Pair<T>)। কিন্তু পরবর্তী impl ব্লকে, Pair<T> কেবল তখনই cmp_display মেথডটি ইমপ্লিমেন্ট করে যদি তার অভ্যন্তরীণ টাইপ T PartialOrd trait ইমপ্লিমেন্ট করে যা তুলনা সক্ষম করে এবং Display trait ইমপ্লিমেন্ট করে যা প্রিন্টিং সক্ষম করে।

use std::fmt::Display;

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

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

আমরা trait bounds সন্তুষ্ট করে এমন যেকোনো টাইপের জন্য একটি trait শর্তসাপেক্ষে ইমপ্লিমেন্ট করতে পারি। এই ধরনের ইমপ্লিমেন্টেশনকে blanket implementations বলা হয় এবং এটি Rust স্ট্যান্ডার্ড লাইব্রেরিতে ব্যাপকভাবে ব্যবহৃত হয়। উদাহরণস্বরূপ, স্ট্যান্ডার্ড লাইব্রেরি Display trait ইমপ্লিমেন্ট করে এমন যেকোনো টাইপের উপর ToString trait ইমপ্লিমেন্ট করে। স্ট্যান্ডার্ড লাইব্রেরিতে impl ব্লকটি এই কোডের মতো দেখতে:

impl<T: Display> ToString for T {
    // --snip--
}

যেহেতু স্ট্যান্ডার্ড লাইব্রেরিতে এই blanket implementation রয়েছে, আমরা Display trait ইমপ্লিমেন্ট করে এমন যেকোনো টাইপের উপর ToString trait দ্বারা সংজ্ঞায়িত to_string মেথড কল করতে পারি। উদাহরণস্বরূপ, আমরা পূর্ণসংখ্যাকে তাদের সংশ্লিষ্ট String মানে পরিণত করতে পারি কারণ পূর্ণসংখ্যা Display ইমপ্লিমেন্ট করে:

#![allow(unused)]
fn main() {
let s = 3.to_string();
}

Blanket implementation গুলি trait-এর ডকুমেন্টেশনে “Implementors” বিভাগে উপস্থিত থাকে।

Traits এবং trait bounds আমাদের জেনেরিক টাইপ প্যারামিটার ব্যবহার করে কোড লিখতে দেয় যা পুনরাবৃত্তি কমায় কিন্তু কম্পাইলারকে নির্দিষ্ট করে দেয় যে আমরা জেনেরিক টাইপের নির্দিষ্ট আচরণ চাই। কম্পাইলার তখন trait bound তথ্য ব্যবহার করে পরীক্ষা করতে পারে যে আমাদের কোডের সাথে ব্যবহৃত সমস্ত concrete টাইপ সঠিক আচরণ প্রদান করে। ডাইনামিক্যালি টাইপড ল্যাঙ্গুয়েজে, আমরা যদি এমন একটি টাইপের উপর একটি মেথড কল করি যা মেথডটি ডিফাইন করে না, তবে আমরা রানটাইমে একটি এরর পেতাম। কিন্তু Rust এই এররগুলিকে কম্পাইল টাইমে নিয়ে আসে যাতে আমরা আমাদের কোড রান করতে সক্ষম হওয়ার আগেই সমস্যাগুলি সমাধান করতে বাধ্য হই। উপরন্তু, আমাদের রানটাইমে আচরণের জন্য পরীক্ষা করার কোড লিখতে হবে না কারণ আমরা ইতিমধ্যে কম্পাইল টাইমে পরীক্ষা করে ফেলেছি। এটি জেনেরিক্সের নমনীয়তা ত্যাগ না করেই পারফরম্যান্স উন্নত করে।

লাইফটাইম দিয়ে রেফারেন্স ভ্যালিডেইট করা

লাইফটাইম (Lifetimes) হলো আরেক ধরনের জেনেরিক যা আমরা ইতিমধ্যে ব্যবহার করে আসছি। একটি টাইপের কাঙ্ক্ষিত আচরণ আছে কিনা তা নিশ্চিত করার পরিবর্তে, লাইফটাইম নিশ্চিত করে যে রেফারেন্সগুলো যতক্ষণ আমাদের প্রয়োজন ততক্ষণ ভ্যালিড থাকবে।

চ্যাপ্টার ৪-এর "রেফারেন্স এবং বরোয়িং" (References and Borrowing) বিভাগে আমরা একটি বিষয় আলোচনা করিনি, তা হলো Rust-এর প্রতিটি রেফারেন্সের একটি লাইফটাইম থাকে, যা হলো সেই স্কোপ যার জন্য রেফারেন্সটি ভ্যালিড। বেশিরভাগ সময়, লাইফটাইমগুলো উহ্য (implicit) এবং অনুমিত (inferred) থাকে, ঠিক যেমন বেশিরভাগ সময় টাইপগুলো অনুমিত থাকে। আমাদের কেবল তখনই টাইপ অ্যানোটেট করতে হয় যখন একাধিক টাইপ সম্ভব হয়। একইভাবে, আমাদের তখনই লাইফটাইম অ্যানোটেট করতে হয় যখন রেফারেন্সগুলোর লাইফটাইম কয়েকটি ভিন্ন উপায়ে সম্পর্কিত হতে পারে। Rust আমাদের এই সম্পর্কগুলো জেনেরিক লাইফটাইম প্যারামিটার ব্যবহার করে অ্যানোটেট করতে বলে, যাতে রানটাইমে ব্যবহৃত আসল রেফারেন্সগুলো অবশ্যই ভ্যালিড থাকে।

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

লাইফটাইম দিয়ে ড্যাংলিং রেফারেন্স প্রতিরোধ করা

লাইফটাইমের মূল উদ্দেশ্য হলো ড্যাংলিং রেফারেন্স (dangling references) প্রতিরোধ করা, যা একটি প্রোগ্রামকে এমন ডেটা রেফারেন্স করতে বাধ্য করে যা তার উদ্দিষ্ট ডেটা নয়। লিস্টিং ১০-১৬-এর প্রোগ্রামটি বিবেচনা করুন, যার একটি বাইরের স্কোপ এবং একটি ভেতরের স্কোপ রয়েছে।

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {r}");
}

দ্রষ্টব্য: লিস্টিং ১০-১৬, ১০-১৭, এবং ১০-২৩ এর উদাহরণগুলোতে ভ্যারিয়েবল ডিক্লেয়ার করা হয়েছে কোনো প্রাথমিক মান না দিয়েই, তাই ভ্যারিয়েবলের নামটি বাইরের স্কোপে বিদ্যমান থাকে। প্রথম নজরে, এটি Rust-এর কোনো null ভ্যালু না থাকার সাথে সাংঘর্ষিক মনে হতে পারে। তবে, যদি আমরা কোনো ভ্যারিয়েবলকে মান দেওয়ার আগে ব্যবহার করার চেষ্টা করি, তাহলে আমরা একটি কম্পাইল-টাইম এরর পাব, যা দেখায় যে Rust সত্যিই null ভ্যালু অনুমোদন করে না।

বাইরের স্কোপটি r নামে একটি ভ্যারিয়েবল ডিক্লেয়ার করে যার কোনো প্রাথমিক মান নেই, এবং ভেতরের স্কোপটি x নামে একটি ভ্যারিয়েবল ডিক্লেয়ার করে যার প্রাথমিক মান 5। ভেতরের স্কোপের মধ্যে, আমরা r-এর মানকে x-এর একটি রেফারেন্স হিসাবে সেট করার চেষ্টা করি। তারপর ভেতরের স্কোপ শেষ হয়ে যায়, এবং আমরা r-এর মান প্রিন্ট করার চেষ্টা করি। এই কোডটি কম্পাইল হবে না কারণ r যে মানটিকে রেফার করছে তা আমরা ব্যবহার করার চেষ্টা করার আগেই স্কোপের বাইরে চলে গেছে। এখানে এরর মেসেজটি হলো:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
 --> src/main.rs:6:13
  |
5 |         let x = 5;
  |             - binding `x` declared here
6 |         r = &x;
  |             ^^ borrowed value does not live long enough
7 |     }
  |     - `x` dropped here while still borrowed
8 |
9 |     println!("r: {r}");
  |                  --- borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

এরর মেসেজটি বলছে যে ভ্যারিয়েবল x "যথেষ্ট দীর্ঘজীবী নয়" (does not live long enough)। কারণটি হলো লাইন ৭-এ ভেতরের স্কোপ শেষ হলে x স্কোপের বাইরে চলে যাবে। কিন্তু r বাইরের স্কোপের জন্য এখনও ভ্যালিড; যেহেতু এর স্কোপটি বড়, আমরা বলি যে এটি "দীর্ঘজীবী" (lives longer)। যদি Rust এই কোডটি কাজ করার অনুমতি দিত, r এমন মেমরি রেফারেন্স করত যা x স্কোপের বাইরে যাওয়ার সময় ডিঅ্যালোকেট হয়ে গিয়েছিল, এবং r দিয়ে আমরা যা করার চেষ্টা করতাম তা সঠিকভাবে কাজ করত না। তাহলে Rust কীভাবে নির্ধারণ করে যে এই কোডটি অবৈধ? এটি একটি borrow checker ব্যবহার করে।

দ্য বরো চেকার (The Borrow Checker)

Rust কম্পাইলারের একটি borrow checker আছে যা স্কোপগুলো তুলনা করে নির্ধারণ করে যে সমস্ত borrow ভ্যালিড কিনা। লিস্টিং ১০-১৭ লিস্টিং ১০-১৬-এর মতো একই কোড দেখায় কিন্তু ভ্যারিয়েবলগুলোর লাইফটাইম দেখানো অ্যানোটেশনসহ।

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {r}");   //          |
}                         // ---------+

এখানে, আমরা r-এর লাইফটাইমকে 'a এবং x-এর লাইফটাইমকে 'b দিয়ে অ্যানোটেট করেছি। जैसा कि आप देख सकते हैं, ভেতরের 'b ব্লকটি বাইরের 'a লাইফটাইম ব্লকের চেয়ে অনেক ছোট। কম্পাইল টাইমে, Rust দুটি লাইফটাইমের আকার তুলনা করে এবং দেখে যে r-এর লাইফটাইম 'a কিন্তু এটি 'b লাইফটাইমযুক্ত মেমরিকে রেফার করে। প্রোগ্রামটি প্রত্যাখ্যান করা হয়েছে কারণ 'b 'a-এর চেয়ে ছোট: রেফারেন্সের বিষয়বস্তুটি রেফারেন্সের মতো দীর্ঘজীবী নয়।

লিস্টিং ১০-১৮ কোডটি ঠিক করে যাতে এটিতে কোনো ড্যাংলিং রেফারেন্স না থাকে এবং এটি কোনো এরর ছাড়াই কম্পাইল হয়।

fn main() {
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {r}");   //   |       |
                          // --+       |
}                         // ----------+

এখানে, x-এর লাইফটাইম 'b, যা এই ক্ষেত্রে 'a-এর চেয়ে বড়। এর মানে হলো r, x-কে রেফারেন্স করতে পারে কারণ Rust জানে যে r-এর রেফারেন্সটি সবসময় ভ্যালিড থাকবে যতক্ষণ x ভ্যালিড থাকে।

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

ফাংশনে জেনেরিক লাইফটাইম

আমরা একটি ফাংশন লিখব যা দুটি স্ট্রিং স্লাইসের মধ্যে দীর্ঘতরটি রিটার্ন করে। এই ফাংশনটি দুটি স্ট্রিং স্লাইস নেবে এবং একটি একক স্ট্রিং স্লাইস রিটার্ন করবে। আমরা longest ফাংশনটি ইমপ্লিমেন্ট করার পরে, লিস্টিং ১০-১৯-এর কোডটি The longest string is abcd প্রিন্ট করা উচিত।

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

লক্ষ্য করুন যে আমরা চাই ফাংশনটি স্ট্রিং স্লাইস (যা রেফারেন্স) নিক, স্ট্রিং নয়, কারণ আমরা চাই না যে longest ফাংশন তার প্যারামিটারগুলোর মালিকানা (ownership) নিয়ে নিক। লিস্টিং ১০-১৯-এ আমরা যে প্যারামিটারগুলো ব্যবহার করি সেগুলো কেন আমরা চাই সে সম্পর্কে আরও আলোচনার জন্য চ্যাপ্টার ৪-এর "প্যারামিটার হিসাবে স্ট্রিং স্লাইস" (String Slices as Parameters) দেখুন।

যদি আমরা লিস্টিং ১০-২০-তে দেখানো হিসাবে longest ফাংশনটি ইমপ্লিমেন্ট করার চেষ্টা করি, তবে এটি কম্পাইল হবে না।

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

পরিবর্তে, আমরা নিম্নলিখিত এররটি পাই যা লাইফটাইম সম্পর্কে কথা বলে:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0106]: missing lifetime specifier
 --> src/main.rs:9:33
  |
9 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ++++     ++          ++          ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

হেল্প টেক্সট প্রকাশ করে যে রিটার্ন টাইপের উপর একটি জেনেরিক লাইফটাইম প্যারামিটার প্রয়োজন কারণ Rust বলতে পারে না যে রিটার্ন করা রেফারেন্সটি x-কে নাকি y-কে রেফার করে। আসলে, আমরাও জানি না, কারণ এই ফাংশনের বডির if ব্লকটি x-এর একটি রেফারেন্স রিটার্ন করে এবং else ব্লকটি y-এর একটি রেফারেন্স রিটার্ন করে!

যখন আমরা এই ফাংশনটি ডিফাইন করছি, তখন আমরা জানি না কোন কংক্রিট (concrete) ভ্যালু এই ফাংশনে পাস করা হবে, তাই আমরা জানি না if কেস না else কেস এক্সিকিউট হবে। আমরা এটাও জানি না যে পাস করা রেফারেন্সগুলোর কংক্রিট লাইফটাইম কী হবে, তাই আমরা লিস্টিং ১০-১৭ এবং ১০-১৮ এর মতো স্কোপগুলো দেখে নির্ধারণ করতে পারি না যে আমাদের রিটার্ন করা রেফারেন্সটি সবসময় ভ্যালিড থাকবে কিনা। বরো চেকারও এটি নির্ধারণ করতে পারে না, কারণ এটি জানে না x এবং y-এর লাইফটাইম রিটার্ন ভ্যালুর লাইফটাইমের সাথে কীভাবে সম্পর্কিত। এই এররটি ঠিক করার জন্য, আমরা জেনেরিক লাইফটাইম প্যারামিটার যোগ করব যা রেফারেন্সগুলোর মধ্যে সম্পর্ক ডিফাইন করবে যাতে বরো চেকার তার বিশ্লেষণ করতে পারে।

লাইফটাইম অ্যানোটেশন সিনট্যাক্স

লাইফটাইম অ্যানোটেশন কোনো রেফারেন্স কতদিন বেঁচে থাকবে তা পরিবর্তন করে না। বরং, তারা লাইফটাইমকে প্রভাবিত না করে একাধিক রেফারেন্সের লাইফটাইমের সম্পর্ক বর্ণনা করে। ঠিক যেমন ফাংশনগুলো যেকোনো টাইপ গ্রহণ করতে পারে যখন সিগনেচার একটি জেনেরিক টাইপ প্যারামিটার নির্দিষ্ট করে, ফাংশনগুলো একটি জেনেরিক লাইফটাইম প্যারামিটার নির্দিষ্ট করে যেকোনো লাইফটাইমসহ রেফারেন্স গ্রহণ করতে পারে।

লাইফটাইম অ্যানোটেশনের একটি কিছুটা অস্বাভাবিক সিনট্যাক্স আছে: লাইফটাইম প্যারামিটারের নাম অবশ্যই একটি অ্যাপস্ট্রফি (') দিয়ে শুরু হতে হবে এবং সাধারণত সবগুলো ছোট হাতের এবং খুব ছোট হয়, জেনেরিক টাইপের মতো। বেশিরভাগ লোক প্রথম লাইফটাইম অ্যানোটেশনের জন্য 'a নামটি ব্যবহার করে। আমরা রেফারেন্সের &-এর পরে লাইফটাইম প্যারামিটার অ্যানোটেশন রাখি, অ্যানোটেশনটিকে রেফারেন্সের টাইপ থেকে আলাদা করার জন্য একটি স্পেস ব্যবহার করে।

এখানে কিছু উদাহরণ দেওয়া হলো: একটি i32-এর রেফারেন্স যাতে কোনো লাইফটাইম প্যারামিটার নেই, একটি i32-এর রেফারেন্স যার 'a নামের একটি লাইফটাইম প্যারামিটার আছে, এবং একটি i32-এর মিউটেবল রেফারেন্স যারও 'a লাইফটাইম আছে।

&i32        // একটি রেফারেন্স
&'a i32     // একটি সুস্পষ্ট লাইফটাইমসহ রেফারেন্স
&'a mut i32 // একটি সুস্পষ্ট লাইফটাইমসহ মিউটেবল রেফারেন্স

একটি লাইফটাইম অ্যানোটেশনের নিজের কোনো বিশেষ অর্থ নেই কারণ অ্যানোটেশনগুলো Rust-কে জানাতে চায় যে একাধিক রেফারেন্সের জেনেরিক লাইফটাইম প্যারামিটারগুলো একে অপরের সাথে কীভাবে সম্পর্কিত। আসুন longest ফাংশনের প্রেক্ষাপটে দেখি লাইফটাইম অ্যানোটেশনগুলো একে অপরের সাথে কীভাবে সম্পর্কিত।

ফাংশন সিগনেচারে লাইফটাইম অ্যানোটেশন

ফাংশন সিগনেচারে লাইফটাইম অ্যানোটেশন ব্যবহার করার জন্য, আমাদের ফাংশনের নাম এবং প্যারামিটার তালিকার মধ্যে অ্যাঙ্গেল ব্র্যাকেটের ভিতরে জেনেরিক লাইফটাইম প্যারামিটার ডিক্লেয়ার করতে হবে, ঠিক যেমন আমরা জেনেরিক টাইপ প্যারামিটারের সাথে করেছিলাম।

আমরা চাই সিগনেচারটি নিম্নলিখিত সীমাবদ্ধতা প্রকাশ করুক: রিটার্ন করা রেফারেন্সটি ততক্ষণ ভ্যালিড থাকবে যতক্ষণ উভয় প্যারামিটার ভ্যালিড থাকবে। এটি প্যারামিটার এবং রিটার্ন ভ্যালুর লাইফটাইমের মধ্যেকার সম্পর্ক। আমরা লাইফটাইমটির নাম দেব 'a এবং তারপর প্রতিটি রেফারেন্সে এটি যোগ করব, যেমনটি লিস্টিং ১০-২১-এ দেখানো হয়েছে।

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

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

এই কোডটি কম্পাইল হওয়া উচিত এবং আমরা যখন লিস্টিং ১০-১৯-এর main ফাংশনের সাথে এটি ব্যবহার করব তখন কাঙ্ক্ষিত ফলাফল তৈরি করা উচিত।

ফাংশন সিগনেচারটি এখন Rust-কে বলছে যে কোনো একটি লাইফটাইম 'a-এর জন্য, ফাংশনটি দুটি প্যারামিটার নেয়, উভয়ই স্ট্রিং স্লাইস যা অন্তত লাইফটাইম 'a পর্যন্ত বেঁচে থাকে। ফাংশন সিগনেচারটি Rust-কে আরও বলছে যে ফাংশন থেকে রিটার্ন করা স্ট্রিং স্লাইসটি অন্তত লাইফটাইম 'a পর্যন্ত বেঁচে থাকবে। বাস্তবে, এর মানে হলো longest ফাংশন দ্বারা রিটার্ন করা রেফারেন্সের লাইফটাইম ফাংশন আর্গুমেন্ট দ্বারা নির্দেশিত মানগুলির লাইফটাইমের মধ্যে যেটি ছোট তার সমান। এই সম্পর্কগুলোই আমরা চাই Rust এই কোড বিশ্লেষণ করার সময় ব্যবহার করুক।

মনে রাখবেন, যখন আমরা এই ফাংশন সিগনেচারে লাইফটাইম প্যারামিটারগুলো নির্দিষ্ট করি, তখন আমরা পাস করা বা রিটার্ন করা কোনো মানের লাইফটাইম পরিবর্তন করছি না। বরং, আমরা নির্দিষ্ট করছি যে বরো চেকার এমন কোনো মান প্রত্যাখ্যান করবে যা এই সীমাবদ্ধতাগুলো মেনে চলে না। লক্ষ্য করুন যে longest ফাংশনটিকে x এবং y ঠিক কতদিন বেঁচে থাকবে তা জানার প্রয়োজন নেই, কেবল এটি জানতে হবে যে 'a-এর জন্য এমন কোনো স্কোপ প্রতিস্থাপন করা যেতে পারে যা এই সিগনেচারটি সন্তুষ্ট করবে।

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

যখন আমরা longest-এ কংক্রিট রেফারেন্স পাস করি, তখন 'a-এর জন্য প্রতিস্থাপিত কংক্রিট লাইফটাইম হলো x-এর স্কোপের সেই অংশ যা y-এর স্কোপের সাথে ওভারল্যাপ করে। অন্য কথায়, জেনেরিক লাইফটাইম 'a সেই কংক্রিট লাইফটাইম পাবে যা x এবং y-এর লাইফটাইমের মধ্যে ছোটটির সমান। যেহেতু আমরা রিটার্ন করা রেফারেন্সটিকে একই লাইফটাইম প্যারামিটার 'a দিয়ে অ্যানোটেট করেছি, তাই রিটার্ন করা রেফারেন্সটিও x এবং y-এর লাইফটাইমের মধ্যে ছোটটির দৈর্ঘ্যের জন্য ভ্যালিড থাকবে।

আসুন দেখি কীভাবে লাইফটাইম অ্যানোটেশনগুলো longest ফাংশনটিকে সীমাবদ্ধ করে, ভিন্ন কংক্রিট লাইফটাইমযুক্ত রেফারেন্স পাস করে। লিস্টিং ১০-২২ একটি সহজ উদাহরণ।

fn main() {
    let string1 = String::from("long string is long");

    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {result}");
    }
}

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

এই উদাহরণে, string1 বাইরের স্কোপের শেষ পর্যন্ত ভ্যালিড, string2 ভেতরের স্কোপের শেষ পর্যন্ত ভ্যালিড, এবং result এমন কিছুকে রেফারেন্স করে যা ভেতরের স্কোপের শেষ পর্যন্ত ভ্যালিড। এই কোডটি চালান এবং আপনি দেখবেন যে বরো চেকার অনুমোদন করে; এটি কম্পাইল হবে এবং The longest string is long string is long প্রিন্ট করবে।

এরপরে, আসুন একটি উদাহরণ চেষ্টা করি যা দেখায় যে result-এর রেফারেন্সের লাইফটাইম অবশ্যই দুটি আর্গুমেন্টের ছোট লাইফটাইম হতে হবে। আমরা result ভ্যারিয়েবলের ডিক্লেয়ারেশন ভেতরের স্কোপের বাইরে নিয়ে যাব কিন্তু result ভ্যারিয়েবলে মানের অ্যাসাইনমেন্ট string2-এর সাথে স্কোপের ভিতরেই রাখব। তারপর আমরা println! যা result ব্যবহার করে তা ভেতরের স্কোপের বাইরে, ভেতরের স্কোপ শেষ হওয়ার পরে নিয়ে যাব। লিস্টিং ১০-২৩-এর কোডটি কম্পাইল হবে না।

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
    }
    println!("The longest string is {result}");
}

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

যখন আমরা এই কোডটি কম্পাইল করার চেষ্টা করি, তখন আমরা এই এররটি পাই:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `string2` does not live long enough
 --> src/main.rs:6:44
  |
5 |         let string2 = String::from("xyz");
  |             ------- binding `string2` declared here
6 |         result = longest(string1.as_str(), string2.as_str());
  |                                            ^^^^^^^ borrowed value does not live long enough
7 |     }
  |     - `string2` dropped here while still borrowed
8 |     println!("The longest string is {result}");
  |                                     -------- borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

এররটি দেখায় যে println! স্টেটমেন্টের জন্য result ভ্যালিড হতে হলে, string2-কে বাইরের স্কোপের শেষ পর্যন্ত ভ্যালিড থাকতে হতো। Rust এটি জানে কারণ আমরা ফাংশন প্যারামিটার এবং রিটার্ন ভ্যালুর লাইফটাইম একই লাইফটাইম প্যারামিটার 'a ব্যবহার করে অ্যানোটেট করেছি।

মানুষ হিসেবে, আমরা এই কোডটি দেখে বুঝতে পারি যে string1 string2-এর চেয়ে দীর্ঘ, এবং তাই result string1-এর একটি রেফারেন্স ধারণ করবে। যেহেতু string1 এখনও স্কোপের বাইরে যায়নি, তাই string1-এর একটি রেফারেন্স println! স্টেটমেন্টের জন্য এখনও ভ্যালিড থাকবে। তবে, কম্পাইলার এই ক্ষেত্রে দেখতে পারে না যে রেফারেন্সটি ভ্যালিড। আমরা Rust-কে বলেছি যে longest ফাংশন দ্বারা রিটার্ন করা রেফারেন্সের লাইফটাইম পাস করা রেফারেন্সগুলোর লাইফটাইমের মধ্যে যেটি ছোট তার সমান। তাই, বরো চেকার লিস্টিং ১০-২৩-এর কোডটিকে সম্ভবত একটি অবৈধ রেফারেন্স থাকার কারণে অনুমোদন করে না।

longest ফাংশনে পাস করা রেফারেন্সগুলোর মান এবং লাইফটাইম এবং রিটার্ন করা রেফারেন্সটি কীভাবে ব্যবহৃত হয় তা পরিবর্তন করে আরও পরীক্ষা ডিজাইন করার চেষ্টা করুন। আপনার পরীক্ষাগুলো বরো চেকার পাস করবে কিনা সে সম্পর্কে অনুমান করুন কম্পাইল করার আগে; তারপর পরীক্ষা করে দেখুন আপনি সঠিক ছিলেন কিনা!

লাইফটাইমের দৃষ্টিকোণ থেকে চিন্তা করা

আপনার ফাংশন কী করছে তার উপর নির্ভর করে আপনাকে কীভাবে লাইফটাইম প্যারামিটার নির্দিষ্ট করতে হবে। উদাহরণস্বরূপ, যদি আমরা longest ফাংশনের ইমপ্লিমেন্টেশন পরিবর্তন করে সবসময় দীর্ঘতম স্ট্রিং স্লাইসের পরিবর্তে প্রথম প্যারামিটারটি রিটার্ন করতাম, তাহলে আমাদের y প্যারামিটারে একটি লাইফটাইম নির্দিষ্ট করার প্রয়োজন হতো না। নিম্নলিখিত কোডটি কম্পাইল হবে:

fn main() {
    let string1 = String::from("abcd");
    let string2 = "efghijklmnopqrstuvwxyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &'a str, y: &str) -> &'a str {
    x
}

আমরা x প্যারামিটার এবং রিটার্ন টাইপের জন্য একটি লাইফটাইম প্যারামিটার 'a নির্দিষ্ট করেছি, কিন্তু y প্যারামিটারের জন্য নয়, কারণ y-এর লাইফটাইমের সাথে x-এর লাইফটাইম বা রিটার্ন ভ্যালুর কোনো সম্পর্ক নেই।

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

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &str, y: &str) -> &'a str {
    let result = String::from("really long string");
    result.as_str()
}

এখানে, যদিও আমরা রিটার্ন টাইপের জন্য একটি লাইফটাইম প্যারামিটার 'a নির্দিষ্ট করেছি, এই ইমপ্লিমেন্টেশনটি কম্পাইল করতে ব্যর্থ হবে কারণ রিটার্ন ভ্যালুর লাইফটাইম প্যারামিটারগুলোর লাইফটাইমের সাথে মোটেও সম্পর্কিত নয়। এখানে আমরা যে এরর মেসেজটি পাই:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0515]: cannot return value referencing local variable `result`
  --> src/main.rs:11:5
   |
11 |     result.as_str()
   |     ------^^^^^^^^^
   |     |
   |     returns a value referencing data owned by the current function
   |     `result` is borrowed here

For more information about this error, try `rustc --explain E0515`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

সমস্যাটি হলো result longest ফাংশনের শেষে স্কোপের বাইরে চলে যায় এবং পরিষ্কার হয়ে যায়। আমরা ফাংশন থেকে result-এর একটি রেফারেন্সও রিটার্ন করার চেষ্টা করছি। এমন কোনো উপায় নেই যে আমরা লাইফটাইম প্যারামিটার নির্দিষ্ট করতে পারি যা ড্যাংলিং রেফারেন্স পরিবর্তন করবে, এবং Rust আমাদের একটি ড্যাংলিং রেফারেন্স তৈরি করতে দেবে না। এই ক্ষেত্রে, সেরা সমাধান হবে একটি ওনড (owned) ডেটা টাইপ রিটার্ন করা, রেফারেন্সের পরিবর্তে, যাতে কলিং ফাংশনটি মান পরিষ্কার করার জন্য দায়ী থাকে।

শেষ পর্যন্ত, লাইফটাইম সিনট্যাক্স বিভিন্ন প্যারামিটার এবং ফাংশনের রিটার্ন ভ্যালুর লাইফটাইম সংযোগ করার বিষয়। একবার সেগুলো সংযুক্ত হয়ে গেলে, Rust-এর কাছে মেমরি-সেফ অপারেশন অনুমোদন করার এবং ড্যাংলিং পয়েন্টার তৈরি বা অন্যথায় মেমরি সেফটি লঙ্ঘনকারী অপারেশনগুলো নিষিদ্ধ করার জন্য যথেষ্ট তথ্য থাকে।

স্ট্রাকট ডেফিনিশনে লাইফটাইম অ্যানোটেশন

এখন পর্যন্ত, আমরা যে struct গুলো ডিফাইন করেছি সেগুলো সবই owned টাইপ ধারণ করে। আমরা রেফারেন্স ধারণ করার জন্য struct ডিফাইন করতে পারি, কিন্তু সেক্ষেত্রে আমাদের struct-এর ডেফিনিশনে প্রতিটি রেফারেন্সের উপর একটি লাইফটাইম অ্যানোটেশন যোগ করতে হবে। লিস্টিং ১০-২৪-এ ImportantExcerpt নামে একটি struct আছে যা একটি স্ট্রিং স্লাইস ধারণ করে।

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

এই struct-টির part নামে একটি মাত্র ফিল্ড আছে যা একটি স্ট্রিং স্লাইস ধারণ করে, যা একটি রেফারেন্স। জেনেরিক ডেটা টাইপের মতো, আমরা struct-এর নামের পরে অ্যাঙ্গেল ব্র্যাকেটের মধ্যে জেনেরিক লাইফটাইম প্যারামিটারের নাম ডিক্লেয়ার করি যাতে আমরা struct ডেফিনিশনের বডিতে লাইফটাইম প্যারামিটার ব্যবহার করতে পারি। এই অ্যানোটেশনের মানে হলো ImportantExcerpt-এর একটি ইনস্ট্যান্স তার part ফিল্ডে থাকা রেফারেন্সের চেয়ে বেশিদিন বাঁচতে পারে না।

এখানকার main ফাংশনটি ImportantExcerpt struct-এর একটি ইনস্ট্যান্স তৈরি করে যা novel ভ্যারিয়েবলের মালিকানাধীন String-এর প্রথম বাক্যের একটি রেফারেন্স ধারণ করে। ImportantExcerpt ইনস্ট্যান্স তৈরি হওয়ার আগে novel-এর ডেটা বিদ্যমান থাকে। উপরন্তু, ImportantExcerpt স্কোপের বাইরে যাওয়ার পরেও novel স্কোপের বাইরে যায় না, তাই ImportantExcerpt ইনস্ট্যান্সের রেফারেন্সটি ভ্যালিড।

লাইফটাইম এলিশন (Lifetime Elision)

আপনি শিখেছেন যে প্রতিটি রেফারেন্সের একটি লাইফটাইম আছে এবং আপনাকে রেফারেন্স ব্যবহার করে এমন ফাংশন বা struct-এর জন্য লাইফটাইম প্যারামিটার নির্দিষ্ট করতে হবে। তবে, আমাদের লিস্টিং ৪-৯-এ একটি ফাংশন ছিল, যা আবার লিস্টিং ১০-২৫-এ দেখানো হয়েছে, যা লাইফটাইম অ্যানোটেশন ছাড়াই কম্পাইল হয়েছে।

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // first_word works on slices of `String`s
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word works on slices of string literals
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

এই ফাংশনটি লাইফটাইম অ্যানোটেশন ছাড়াই কম্পাইল হওয়ার কারণটি ঐতিহাসিক: Rust-এর প্রাথমিক সংস্করণগুলোতে (১.০-এর আগে), এই কোডটি কম্পাইল হতো না কারণ প্রতিটি রেফারেন্সের জন্য একটি সুস্পষ্ট লাইফটাইম প্রয়োজন ছিল। সেই সময়ে, ফাংশন সিগনেচারটি এভাবে লেখা হতো:

fn first_word<'a>(s: &'a str) -> &'a str {

অনেক Rust কোড লেখার পর, Rust টিম দেখতে পেল যে Rust প্রোগ্রামাররা নির্দিষ্ট পরিস্থিতিতে বারবার একই লাইফটাইম অ্যানোটেশন লিখছে। এই পরিস্থিতিগুলো অনুমানযোগ্য ছিল এবং কয়েকটি ডিটারমিনিস্টিক প্যাটার্ন অনুসরণ করত। ডেভেলপাররা এই প্যাটার্নগুলো কম্পাইলারের কোডে প্রোগ্রাম করে দিয়েছে যাতে বরো চেকার এই পরিস্থিতিতে লাইফটাইমগুলো অনুমান করতে পারে এবং সুস্পষ্ট অ্যানোটেশনের প্রয়োজন না হয়।

Rust ইতিহাসের এই অংশটি প্রাসঙ্গিক কারণ ভবিষ্যতে আরও ডিটারমিনিস্টিক প্যাটার্ন ortaya আসতে পারে এবং কম্পাইলারে যোগ করা হতে পারে। ভবিষ্যতে, আরও কম লাইফটাইম অ্যানোটেশনের প্রয়োজন হতে পারে।

Rust-এর রেফারেন্স বিশ্লেষণের মধ্যে প্রোগ্রাম করা প্যাটার্নগুলোকে লাইফটাইম এলিশন রুলস (lifetime elision rules) বলা হয়। এগুলো প্রোগ্রামারদের অনুসরণ করার নিয়ম নয়; এগুলো এমন কিছু বিশেষ কেসের সেট যা কম্পাইলার বিবেচনা করবে, এবং যদি আপনার কোড এই কেসগুলোর সাথে মিলে যায়, তাহলে আপনাকে সুস্পষ্টভাবে লাইফটাইম লেখার প্রয়োজন নেই।

এলিশন রুলস সম্পূর্ণ অনুমান প্রদান করে না। যদি Rust রুলস প্রয়োগ করার পরেও রেফারেন্সগুলোর লাইফটাইম সম্পর্কে অস্পষ্টতা থাকে, কম্পাইলার বাকি রেফারেন্সগুলোর লাইফটাইম কী হওয়া উচিত তা অনুমান করবে না। অনুমান করার পরিবর্তে, কম্পাইলার আপনাকে একটি এরর দেবে যা আপনি লাইফটাইম অ্যানোটেশন যোগ করে সমাধান করতে পারেন।

ফাংশন বা মেথড প্যারামিটারে লাইফটাইমকে ইনপুট লাইফটাইম (input lifetimes) বলা হয়, এবং রিটার্ন ভ্যালুতে লাইফটাইমকে আউটপুট লাইফটাইম (output lifetimes) বলা হয়।

কম্পাইলার যখন সুস্পষ্ট অ্যানোটেশন না থাকে তখন রেফারেন্সের লাইফটাইম বের করার জন্য তিনটি নিয়ম ব্যবহার করে। প্রথম নিয়মটি ইনপুট লাইফটাইমের জন্য প্রযোজ্য, এবং দ্বিতীয় ও তৃতীয় নিয়ম আউটপুট লাইফটাইমের জন্য প্রযোজ্য। যদি কম্পাইলার তিনটি নিয়ম শেষে পৌঁছানোর পরেও এমন রেফারেন্স থাকে যার লাইফটাইম বের করতে পারে না, কম্পাইলার একটি এরর দিয়ে থেমে যাবে। এই নিয়মগুলো fn ডেফিনিশন এবং impl ব্লকের জন্য প্রযোজ্য।

প্রথম নিয়মটি হলো কম্পাইলার প্রতিটি প্যারামিটার যা একটি রেফারেন্স, তাকে একটি লাইফটাইম প্যারামিটার বরাদ্দ করে। অন্য কথায়, একটি প্যারামিটারযুক্ত একটি ফাংশন একটি লাইফটাইম প্যারামিটার পায়: fn foo<'a>(x: &'a i32); দুটি প্যারামিটারযুক্ত একটি ফাংশন দুটি পৃথক লাইফটাইম প্যারামিটার পায়: fn foo<'a, 'b>(x: &'a i32, y: &'b i32); এবং এভাবেই চলতে থাকে।

দ্বিতীয় নিয়মটি হলো, যদি ঠিক একটি ইনপুট লাইফটাইম প্যারামিটার থাকে, তবে সেই লাইফটাইমটি সমস্ত আউটপুট লাইফটাইম প্যারামিটারে বরাদ্দ করা হয়: fn foo<'a>(x: &'a i32) -> &'a i32।

তৃতীয় নিয়মটি হলো, যদি একাধিক ইনপুট লাইফটাইম প্যারামিটার থাকে, কিন্তু তাদের মধ্যে একটি &self বা &mut self হয় কারণ এটি একটি মেথড, তবে self-এর লাইফটাইম সমস্ত আউটপুট লাইফটাইম প্যারামিটারে বরাদ্দ করা হয়। এই তৃতীয় নিয়মটি মেথডগুলোকে পড়া এবং লেখা অনেক সুন্দর করে তোলে কারণ কম প্রতীকের প্রয়োজন হয়।

চলুন আমরা কম্পাইলারের মতো ভান করি। আমরা লিস্টিং ১০-২৫-এর first_word ফাংশনের সিগনেচারে রেফারেন্সের লাইফটাইম বের করার জন্য এই নিয়মগুলো প্রয়োগ করব। সিগনেচারটি রেফারেন্সের সাথে কোনো লাইফটাইম যুক্ত না করে শুরু হয়:

fn first_word(s: &str) -> &str {

তারপর কম্পাইলার প্রথম নিয়মটি প্রয়োগ করে, যা নির্দিষ্ট করে যে প্রতিটি প্যারামিটার তার নিজস্ব লাইফটাইম পায়। আমরা এটিকে যথারীতি 'a বলব, তাই এখন সিগনেচারটি হলো:

fn first_word<'a>(s: &'a str) -> &str {

দ্বিতীয় নিয়মটি প্রযোজ্য কারণ ঠিক একটি ইনপুট লাইফটাইম আছে। দ্বিতীয় নিয়মটি নির্দিষ্ট করে যে একটি ইনপুট প্যারামিটারের লাইফটাইম আউটপুট লাইফটাইমে বরাদ্দ করা হয়, তাই সিগনেচারটি এখন হলো:

fn first_word<'a>(s: &'a str) -> &'a str {

এখন এই ফাংশন সিগনেচারের সমস্ত রেফারেন্সের লাইফটাইম আছে, এবং কম্পাইলার প্রোগ্রামারকে এই ফাংশন সিগনেচারে লাইফটাইম অ্যানোটেট করার প্রয়োজন ছাড়াই তার বিশ্লেষণ চালিয়ে যেতে পারে।

আসুন আরেকটি উদাহরণ দেখি, এবার longest ফাংশনটি ব্যবহার করে যা আমরা লিস্টিং ১০-২০-এ কাজ শুরু করার সময় কোনো লাইফটাইম প্যারামিটার ছিল না:

fn longest(x: &str, y: &str) -> &str {

আসুন প্রথম নিয়মটি প্রয়োগ করি: প্রতিটি প্যারামিটার তার নিজস্ব লাইফটাইম পায়। এবার আমাদের একটির পরিবর্তে দুটি প্যারামিটার আছে, তাই আমাদের দুটি লাইফটাইম আছে:

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {

আপনি দেখতে পাচ্ছেন যে দ্বিতীয় নিয়মটি প্রযোজ্য নয় কারণ একাধিক ইনপুট লাইফটাইম আছে। তৃতীয় নিয়মটিও প্রযোজ্য নয়, কারণ longest একটি ফাংশন, মেথড নয়, তাই কোনো প্যারামিটার self নয়। তিনটি নিয়ম কাজ করার পরেও, আমরা এখনও বের করতে পারিনি যে রিটার্ন টাইপের লাইফটাইম কী। এই কারণেই আমরা লিস্টিং ১০-২০-এর কোড কম্পাইল করার চেষ্টা করার সময় একটি এরর পেয়েছিলাম: কম্পাইলার লাইফটাইম এলিশন রুলস কাজ করেছে কিন্তু এখনও সিগনেচারের সমস্ত রেফারেন্সের লাইফটাইম বের করতে পারেনি।

যেহেতু তৃতীয় নিয়মটি সত্যিই কেবল মেথড সিগনেচারে প্রযোজ্য, আমরা পরবর্তী অংশে সেই প্রেক্ষাপটে লাইফটাইম দেখব কেন তৃতীয় নিয়মের মানে হলো আমাদের মেথড সিগনেচারে খুব কমই লাইফটাইম অ্যানোটেট করতে হয়।

মেথড ডেফিনিশনে লাইফটাইম অ্যানোটেশন

যখন আমরা লাইফটাইমসহ একটি struct-এ মেথড ইমপ্লিমেন্ট করি, তখন আমরা জেনেরিক টাইপ প্যারামিটারের মতো একই সিনট্যাক্স ব্যবহার করি, যেমনটি লিস্টিং ১০-১১-এ দেখানো হয়েছে। আমরা কোথায় লাইফটাইম প্যারামিটার ডিক্লেয়ার এবং ব্যবহার করি তা নির্ভর করে সেগুলো struct ফিল্ড বা মেথড প্যারামিটার এবং রিটার্ন ভ্যালুর সাথে সম্পর্কিত কিনা তার উপর।

struct ফিল্ডের জন্য লাইফটাইম নাম সবসময় impl কিওয়ার্ডের পরে ডিক্লেয়ার করতে হবে এবং তারপর struct-এর নামের পরে ব্যবহার করতে হবে কারণ সেই লাইফটাইমগুলো struct-এর টাইপের অংশ।

impl ব্লকের ভিতরে মেথড সিগনেচারে, রেফারেন্সগুলো struct-এর ফিল্ডে থাকা রেফারেন্সের লাইফটাইমের সাথে আবদ্ধ হতে পারে, অথবা সেগুলো স্বাধীন হতে পারে। উপরন্তু, লাইফটাইম এলিশন রুলস প্রায়শই মেথড সিগনেচারে লাইফটাইম অ্যানোটেশনের প্রয়োজন হয় না। আসুন আমরা লিস্টিং ১০-২৪-এ সংজ্ঞায়িত ImportantExcerpt নামক struct ব্যবহার করে কিছু উদাহরণ দেখি।

প্রথমে আমরা level নামের একটি মেথড ব্যবহার করব যার একমাত্র প্যারামিটার হলো self-এর একটি রেফারেন্স এবং যার রিটার্ন ভ্যালু একটি i32, যা কোনো কিছুর রেফারেন্স নয়:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {announcement}");
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

impl-এর পরে লাইফটাইম প্যারামিটার ডিক্লেয়ারেশন এবং টাইপের নামের পরে এর ব্যবহার প্রয়োজন, কিন্তু প্রথম এলিশন রুলের কারণে আমাদের self-এর রেফারেন্সের লাইফটাইম অ্যানোটেট করার প্রয়োজন নেই।

এখানে একটি উদাহরণ যেখানে তৃতীয় লাইফটাইম এলিশন রুল প্রযোজ্য:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {announcement}");
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

দুটি ইনপুট লাইফটাইম আছে, তাই Rust প্রথম লাইফটাইম এলিশন রুল প্রয়োগ করে এবং &self এবং announcement উভয়কেই তাদের নিজস্ব লাইফটাইম দেয়। তারপর, যেহেতু প্যারামিটারগুলোর মধ্যে একটি &self, রিটার্ন টাইপ &self-এর লাইফটাইম পায়, এবং সমস্ত লাইফটাইম হিসাব করা হয়েছে।

স্ট্যাটিক লাইফটাইম (The Static Lifetime)

একটি বিশেষ লাইফটাইম যা আমাদের আলোচনা করতে হবে তা হলো 'static, যা বোঝায় যে প্রভাবিত রেফারেন্সটি প্রোগ্রামের পুরো সময়কাল ধরে বেঁচে থাকতে পারে। সমস্ত স্ট্রিং লিটারেলের 'static লাইফটাইম থাকে, যা আমরা নিম্নরূপ অ্যানোটেট করতে পারি: