Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

use keyword দিয়ে path-কে scope-এ আনা

function call করতে path লিখে যেতে হওয়াটা অসুবিধাজনক আর একঘেয়ে লাগতে পারে। Listing 7-7-এ add_to_waitlist function-এর জন্য absolute বা relative যে path-ই বেছে নিই না কেন, যতবার add_to_waitlist call করতে চেয়েছি, ততবার front_of_house আর hosting-ও লিখতে হয়েছে। সৌভাগ্যক্রমে, এই প্রক্রিয়া সহজ করার একটি উপায় আছে: use keyword দিয়ে একবার একটি path-এর শর্টকাট তৈরি করে scope-এর বাকি সবখানে ছোট নামটি ব্যবহার করতে পারি।

Listing 7-11-এ আমরা crate::front_of_house::hosting module-টিকে eat_at_restaurant function-এর scope-এ আনি, যাতে eat_at_restaurant-এ add_to_waitlist function call করতে শুধু hosting::add_to_waitlist লিখলেই চলে।

Filename: src/lib.rs
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();
}
Listing 7-11: use দিয়ে একটি module-কে scope-এ আনা

একটি scope-এ use আর একটি path যোগ করা ফাইল সিস্টেমে একটি symbolic link (ফাইল বা ডিরেক্টরির শর্টকাট-লিংক) তৈরির মতো। crate root-এ use crate::front_of_house::hosting যোগ করায় hosting এখন ওই scope-এ একটি বৈধ নাম, ঠিক যেন hosting module crate root-এই সংজ্ঞায়িত হয়েছিল। use দিয়ে scope-এ আনা path-ও অন্য যেকোনো path-এর মতো privacy যাচাই করে।

লক্ষ করুন, use শুধু সেই নির্দিষ্ট scope-এর জন্যই শর্টকাট তৈরি করে, যেখানে use আছে। Listing 7-12-এ eat_at_restaurant function-কে customer নামের একটি নতুন child module-এ সরানো হয়েছে, যা তখন use statement-এর থেকে আলাদা একটি scope, তাই function body compile হবে না।

Filename: src/lib.rs
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();
    }
}
Listing 7-12: একটি use statement শুধু সেই scope-এই প্রযোজ্য, যেখানে এটি আছে।

compiler error দেখায় যে customer module-এর ভেতরে শর্টকাটটি আর প্রযোজ্য নয়:

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0433]: failed to resolve: use of unresolved module or unlinked crate `hosting`
  --> src/lib.rs:11:9
   |
11 |         hosting::add_to_waitlist();
   |         ^^^^^^^ use of unresolved module or unlinked crate `hosting`
   |
   = help: if you wanted to use a crate named `hosting`, use `cargo add hosting` to add it to your `Cargo.toml`
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-টি তার scope-এ আর ব্যবহার হচ্ছে না! এই সমস্যা ঠিক করতে use-টিকেও customer module-এর ভেতরে সরিয়ে নিন, অথবা child customer module-এর ভেতর থেকে super::hosting দিয়ে parent module-এর শর্টকাটটি উল্লেখ করুন।

Rust-সুলভ use path তৈরি করা

Listing 7-11-এ আপনি হয়তো ভেবেছেন, Listing 7-13-এর মতো একই ফল পেতে use path-টি একেবারে add_to_waitlist function পর্যন্ত লেখার বদলে আমরা কেন use crate::front_of_house::hosting লিখে তারপর eat_at_restaurant-এ hosting::add_to_waitlist call করলাম।

Filename: src/lib.rs
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-13: use দিয়ে add_to_waitlist function-কে scope-এ আনা, যা Rust-সুলভ নয়

Listing 7-11 আর Listing 7-13 দুটোই একই কাজ করলেও use দিয়ে একটি function-কে scope-এ আনার Rust-সুলভ উপায় হলো Listing 7-11। use দিয়ে function-এর parent module-কে scope-এ আনা মানে function call করার সময় আমাদের parent module লিখতে হবে। function call করার সময় parent module লিখলে স্পষ্ট হয় যে function-টি লোকালভাবে সংজ্ঞায়িত নয়, আবার পুরো path বারবার লেখাও কম হয়। Listing 7-13-এর কোডে add_to_waitlist কোথায় সংজ্ঞায়িত, তা অস্পষ্ট।

অন্যদিকে, use দিয়ে struct, enum আর অন্যান্য item আনার সময় পুরো path লেখাই Rust-সুলভ। Listing 7-14-এ একটি binary crate-এর scope-এ standard library-র HashMap struct আনার Rust-সুলভ উপায় দেখানো হয়েছে।

Filename: src/main.rs
use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}
Listing 7-14: Rust-সুলভ উপায়ে HashMap-কে scope-এ আনা

এই idiom (Rust-এর প্রচলিত লেখার ধরন)-এর পেছনে জোরালো কোনো কারণ নেই: এটি শুধু একটি রীতি, যা গড়ে উঠেছে, আর মানুষজন এভাবে Rust কোড পড়তে ও লিখতে অভ্যস্ত হয়ে গেছেন।

এই idiom-এর ব্যতিক্রম হলো, যদি আমরা use statement দিয়ে একই নামের দুটি item scope-এ আনি, কারণ Rust তা করতে দেয় না। Listing 7-15-এ দেখানো হয়েছে, একই নামের কিন্তু আলাদা parent module-এর দুটি Result type কীভাবে scope-এ আনতে হয় এবং কীভাবে সেগুলো উল্লেখ করতে হয়।

Filename: src/lib.rs
use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn function2() -> io::Result<()> {
    // --snip--
    Ok(())
}
Listing 7-15: একই নামের দুটি type একই scope-এ আনতে তাদের parent module ব্যবহার করতে হয়।

দেখতেই পাচ্ছেন, parent module ব্যবহার করে দুটি Result type আলাদা করা যায়। এর বদলে আমরা যদি use std::fmt::Result আর use std::io::Result লিখতাম, তাহলে একই scope-এ দুটি Result type থাকত, আর Result ব্যবহার করলে আমরা কোনটি বোঝাচ্ছি, Rust তা জানত না।

as keyword দিয়ে নতুন নাম দেওয়া

use দিয়ে একই নামের দুটি type একই scope-এ আনার সমস্যার আরেকটি সমাধান আছে: path-এর পরে আমরা as আর type-টির জন্য একটি নতুন লোকাল নাম, বা alias (বিকল্প নাম), লিখতে পারি। Listing 7-16-এ as ব্যবহার করে দুটি Result type-এর একটির নাম বদলে Listing 7-15-এর কোড লেখার আরেকটি উপায় দেখানো হয়েছে।

Filename: src/lib.rs
use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
    Ok(())
}

fn function2() -> IoResult<()> {
    // --snip--
    Ok(())
}
Listing 7-16: scope-এ আনার সময় as keyword দিয়ে একটি type-এর নাম বদলানো

দ্বিতীয় use statement-এ আমরা std::io::Result type-এর জন্য নতুন নাম IoResult বেছে নিয়েছি, যা std::fmt-এর Result-এর সঙ্গে সংঘাত ঘটাবে না, যেটিও আমরা scope-এ এনেছি। Listing 7-15 আর Listing 7-16 দুটোই Rust-সুলভ বলে গণ্য, তাই বেছে নেওয়া আপনার ওপর!

pub use দিয়ে নাম re-export করা

use keyword দিয়ে কোনো নাম scope-এ আনলে নামটি সেই scope-এর কাছে private থাকে, যেখানে আমরা এটি import করেছি। ওই scope-এর বাইরের কোডকে নামটি এমনভাবে উল্লেখ করতে দিতে, যেন এটি ওই scope-এই সংজ্ঞায়িত, আমরা pub আর use মিলিয়ে ব্যবহার করতে পারি। এই কৌশলকে বলা হয় re-exporting (আনা নামকে আবার বাইরে প্রকাশ করা), কারণ আমরা একটি item-কে scope-এ আনছি, আবার সেই item-কে অন্যদের নিজেদের scope-এ আনার জন্যও উন্মুক্ত করছি।

Listing 7-17-এ Listing 7-11-এর কোডটি দেখানো হয়েছে, যেখানে root module-এর use বদলে pub use করা হয়েছে।

Filename: src/lib.rs
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();
}
Listing 7-17: pub use দিয়ে একটি নামকে নতুন scope থেকে যেকোনো কোডের ব্যবহারের জন্য উন্মুক্ত করা

এই পরিবর্তনের আগে বাইরের কোডকে add_to_waitlist function call করতে হতো restaurant::front_of_house::hosting::add_to_waitlist() path ব্যবহার করে, যার জন্য front_of_house module-কেও pub হিসেবে চিহ্নিত করতে হতো। এখন এই pub use root module থেকে hosting module-টি re-export করায় বাইরের কোড এর বদলে restaurant::hosting::add_to_waitlist() path ব্যবহার করতে পারে।

re-export কাজে আসে, যখন আপনার কোডের ভেতরের কাঠামো আপনার কোড call করা প্রোগ্রামাররা বিষয়টি যেভাবে ভাবেন, তার থেকে আলাদা। যেমন, এই রেস্তোরাঁর রূপকে রেস্তোরাঁ চালানো মানুষেরা “front of house” আর “back of house” হিসেবে ভাবেন। কিন্তু রেস্তোরাঁয় আসা খদ্দেররা সম্ভবত রেস্তোরাঁর অংশগুলোকে এই শব্দে ভাবেন না। pub use দিয়ে আমরা এক কাঠামোয় কোড লিখে ভিন্ন একটি কাঠামো প্রকাশ করতে পারি। এতে আমাদের library, library-তে কাজ করা প্রোগ্রামার আর library call করা প্রোগ্রামার—দুই দলের জন্যই সুসংগঠিত হয়। pub use-এর আরেকটি উদাহরণ আর এটি কীভাবে আপনার crate-এর ডকুমেন্টেশনকে প্রভাবিত করে, তা আমরা অধ্যায় 14-এর “সুবিধাজনক public API export করা” অংশে দেখব।

বাইরের package ব্যবহার করা

অধ্যায় 2-এ আমরা একটি সংখ্যা আন্দাজের খেলার প্রজেক্ট প্রোগ্রাম করেছিলাম, যা র‍্যান্ডম সংখ্যা পেতে rand নামের একটি বাইরের package ব্যবহার করেছিল। আমাদের প্রজেক্টে rand ব্যবহার করতে আমরা Cargo.toml-এ এই লাইনটি যোগ করেছিলাম:

Filename: Cargo.toml
rand = "0.8.5"

Cargo.toml-এ rand-কে dependency হিসেবে যোগ করলে Cargo-কে বলা হয় crates.io থেকে rand package আর এর সব dependency ডাউনলোড করে rand-কে আমাদের প্রজেক্টের জন্য উন্মুক্ত করতে।

তারপর আমাদের package-এর scope-এ rand-এর সংজ্ঞাগুলো আনতে আমরা crate-এর নাম rand দিয়ে শুরু হওয়া একটি use লাইন যোগ করেছিলাম, আর যে item-গুলো scope-এ আনতে চেয়েছিলাম, সেগুলো তালিকাভুক্ত করেছিলাম। মনে করুন, অধ্যায় 2-এর “একটি র‍্যান্ডম সংখ্যা তৈরি করা” অংশে আমরা Rng trait-কে scope-এ এনে rand::thread_rng function call করেছিলাম:

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}");
}

Rust কমিউনিটির সদস্যরা crates.io-তে অনেক package উন্মুক্ত করেছেন, আর সেগুলোর যেকোনোটি আপনার package-এ আনতে এই একই ধাপগুলো অনুসরণ করতে হয়: আপনার package-এর Cargo.toml ফাইলে সেগুলো তালিকাভুক্ত করা, আর তাদের crate থেকে item scope-এ আনতে use ব্যবহার করা।

লক্ষ করুন, standard std library-ও একটি crate, যা আমাদের package-এর বাইরের। standard library যেহেতু Rust ভাষার সঙ্গেই আসে, তাই std যোগ করতে আমাদের Cargo.toml বদলাতে হয় না। কিন্তু সেখান থেকে item আমাদের package-এর scope-এ আনতে use দিয়ে একে উল্লেখ করতে হয়। যেমন, HashMap-এর জন্য আমরা এই লাইনটি ব্যবহার করতাম:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

এটি একটি absolute path, যা শুরু হয়েছে standard library crate-এর নাম std দিয়ে।

nested path দিয়ে use তালিকা পরিষ্কার করা

একই crate বা একই module-এ সংজ্ঞায়িত একাধিক item ব্যবহার করলে প্রতিটি item আলাদা লাইনে লিখলে আমাদের ফাইলে অনেকটা খাড়া জায়গা নিতে পারে। যেমন, Listing 2-4-এর সংখ্যা আন্দাজের খেলায় আমাদের এই দুটি use statement std থেকে item scope-এ আনে:

Filename: src/main.rs
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!"),
    }
}

এর বদলে আমরা nested path (একই শুরুর অংশের পথগুলো {} দিয়ে একত্র করা) ব্যবহার করে একই item-গুলো এক লাইনেই scope-এ আনতে পারি। এটি করতে path-এর সাধারণ অংশটি লিখি, তারপর দুটি কোলন, আর তারপর কার্লি ব্র্যাকেটের ভেতরে path-গুলোর আলাদা অংশগুলোর একটি তালিকা, Listing 7-18-এ যেমন দেখানো হয়েছে।

Filename: src/main.rs
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 7-18: একই উপসর্গের একাধিক item scope-এ আনতে একটি nested path লেখা

বড় প্রোগ্রামে nested path ব্যবহার করে একই crate বা module থেকে অনেক item scope-এ আনলে দরকারি আলাদা use statement-এর সংখ্যা অনেক কমে যেতে পারে!

path-এর যেকোনো স্তরে nested path ব্যবহার করা যায়, যা কাজে আসে যখন একটি উপ-path ভাগ করে এমন দুটি use statement মেলাতে হয়। যেমন, Listing 7-19-এ দুটি use statement দেখানো হয়েছে: একটি std::io-কে scope-এ আনে, আর অন্যটি std::io::Write-কে।

Filename: src/lib.rs
use std::io;
use std::io::Write;
Listing 7-19: দুটি use statement, যেখানে একটি অন্যটির উপ-path

এই দুটি path-এর সাধারণ অংশ হলো std::io, আর সেটিই প্রথম path-টির পুরোটা। এই দুটি path-কে একটি use statement-এ মেলাতে আমরা nested path-এ self ব্যবহার করতে পারি, Listing 7-20-এ যেমন দেখানো হয়েছে।

Filename: src/lib.rs
use std::io::{self, Write};
Listing 7-20: Listing 7-19-এর path-গুলোকে একটি use statement-এ মেলানো

এই লাইনটি std::io আর std::io::Write দুটোকেই scope-এ আনে।

glob operator দিয়ে item import করা

একটি path-এ সংজ্ঞায়িত সব public item scope-এ আনতে চাইলে সেই path-এর পরে * glob operator (* দিয়ে সব public item একসঙ্গে আনার চিহ্ন) লিখতে পারি:

#![allow(unused)]
fn main() {
use std::collections::*;
}

এই use statement std::collections-এ সংজ্ঞায়িত সব public item বর্তমান scope-এ আনে। glob operator ব্যবহারের সময় সতর্ক থাকুন! glob ব্যবহার করলে কোন কোন নাম scope-এ আছে, আর আপনার প্রোগ্রামে ব্যবহৃত একটি নাম কোথায় সংজ্ঞায়িত, তা বোঝা কঠিন হয়ে যেতে পারে। এছাড়া dependency তার সংজ্ঞা বদলালে আপনি যা import করেছেন তা-ও বদলে যায়, যার ফলে dependency আপগ্রেড করলে compiler error হতে পারে, যেমন যদি dependency এমন একটি সংজ্ঞা যোগ করে, যার নাম একই scope-এ আপনার একটি সংজ্ঞার নামের সমান।

glob operator প্রায়ই testing-এর সময় ব্যবহার হয়, পরীক্ষাধীন সবকিছু tests module-এ আনতে; এ নিয়ে আমরা অধ্যায় 11-এর “test কীভাবে লিখতে হয়” অংশে কথা বলব। glob operator কখনো কখনো prelude ধরনের অংশ হিসেবেও ব্যবহার হয়: এই ধরন সম্পর্কে আরও জানতে standard library-র ডকুমেন্টেশন দেখুন।