লুসিয়ানের সুস্বাদু লাসাগনা

Rust-এ একটি নামের সাথে একটি মান যুক্ত করাকে বাইন্ডিং বলা হয়। mut কিওয়ার্ড দিয়ে ঘোষণা করা না হলে বাইন্ডিং ইমিউটেবল থাকে। Rust যেহেতু একটি স্ট্যাটিক-টাইপড ভাষা, তাই প্রতিটি বাইন্ডিংয়ের একটি টাইপ থাকে যা কম্পাইল টাইমেই জানা যায়।

বেশিরভাগ বাইন্ডিং let কিওয়ার্ড দিয়ে ডিফাইন করা হয়। অধিকাংশ বাইন্ডিংয়ের ক্ষেত্রে টাইপ উল্লেখ করা ঐচ্ছিক, কারণ Rust-এর টাইপ ইনফারেন্স সাধারণত মান দেখে টাইপ অনুমান করতে পারে। একটি বাইন্ডিং দেখতে এমন হয়:

// Automatically inferred type
let fingers = 10;

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

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

fn add(x: i32, y: i32) -> i32 {
  x + y
}

একটি ফাংশন কল করতে তার নাম লিখে তারপর বন্ধনী দিতে হয়। ফাংশনের প্যারামিটার থাকলে প্রতিটির জন্য বন্ধনীর ভেতরে একটি আর্গুমেন্ট উল্লেখ করতে হয়।

let five = add(2, 3);

কোনো বাইন্ডিংয়ের টাইপ অনুমান করা না গেলে কম্পাইলার একটি এরর দেখাবে। এটি ঠিক করতে বাইন্ডিংটিতে স্পষ্টভাবে টাইপ অ্যানোটেশন যোগ করুন।

// Explicit type annotation
let fingers: i32 = 10;

Rust-এ আইটেম ডিফাইন করার আগে বা পরে, দুটোই ব্যবহার করা যায়, কারণ এগুলোর জীবনকাল স্ট্যাটিক। অন্যদিকে বাইন্ডিং শুধু ডিফাইন করার পরে ব্যবহার করা যায়। ডিফাইন করার আগে বাইন্ডিং ব্যবহার করলে কম্পাইল এরর হয়।

fn main() {
    // `fn add` hasn't yet been defined, but that's perfectly ok
    dbg!(add(3, 4));
}

fn add(x: i32, y: i32) -> i32 {
  x + y
}

// this won't compile; `a` is used before its binding is defined
let b = a;
let a = x + y;

Rust একটি স্কোপ ডিফাইন করতে কার্লি ব্রেস ({}) ব্যবহার করে। কোনো স্কোপের ভেতরে ডিফাইন করা বাইন্ডিং সেই স্কোপ থেকে বেরিয়ে যেতে পারে না।

let a = 1;
dbg!(a); // 1
{
    // Here, we re-bind `a` to a new value, which is still immutable.
    // This technique is called _shadowing_. The new binding is constrained to
    // this anonymous scope. Outside this scope, the previous binding still
    // applies.
    let a = 2;
    let b = 3;
    dbg!(a, b); // 2, 3
}
// can't use `b` anymore because it is out of scope
// dbg!(b);

// The shadowed `a` in the inner scope above has fallen out of scope,
// leaving us with our original binding.
dbg!(a); // 1

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

mod calc_i32 {
    fn add(a: i32, b: i32) -> i32 { a + b }
    fn sub(a: i32, b: i32) -> i32 { a - b }
    fn mul(a: i32, b: i32) -> i32 { a * b }
    fn div(a: i32, b: i32) -> i32 { a / b }
}

Rust দুই ধরনের কমেন্ট সমর্থন করে। // কিওয়ার্ডটি একটি একলাইন কমেন্ট বোঝায়; কিওয়ার্ডটির পর থেকে লাইনের শেষ পর্যন্ত সবকিছু উপেক্ষা করা হয়। /* ও */ কিওয়ার্ড দুটি একটি বহুলাইন কমেন্ট বোঝায়; এই দুটি কিওয়ার্ডের ভেতরের সবকিছু উপেক্ষা করা হয়। একলাইন কমেন্ট ব্যবহার করাই রীতিসম্মত এবং ভালো অভ্যাস।

Rust ডক-কমেন্টও সমর্থন করে, যেগুলো cargo doc দিয়ে তৈরি হওয়া ডকুমেন্টেশনে দেখা যায়। আউটার ডক-কমেন্ট তৈরি হয় /// কিওয়ার্ড দিয়ে, যা // কিওয়ার্ডের মতোই কাজ করে। এগুলো তার পরে আসা আইটেমের ক্ষেত্রে প্রযোজ্য, যেমন একটি ফাংশন:

/// The `add` function produces the sum of its arguments.
fn add(x: i32, y: i32) -> i32 { x + y }

ইনার ডক-কমেন্ট তৈরি হয় //! কিওয়ার্ড দিয়ে, যা // কিওয়ার্ডের মতোই কাজ করে। এগুলো যে আইটেমের ভেতরে থাকে তার ক্ষেত্রে প্রযোজ্য, যেমন একটি মডিউল:

mod my_cool_module {
    //! This module is the bee's knees.
}

ডক-কমেন্ট যেকোনো দৈর্ঘ্যের হতে পারে এবং এতে markdown থাকতে পারে, যা তৈরি হওয়া ডকুমেন্টেশনে রেন্ডার হয়।