panic! করব নাকি করব না
তাহলে কখন panic! call করা উচিত আর কখন Result return করা উচিত, তা কীভাবে ঠিক করবেন? কোড panic করলে সামলে ওঠার কোনো উপায়
থাকে না। সামলে ওঠার কোনো সম্ভাব্য উপায় থাকুক বা না থাকুক, যেকোনো error-এর পরিস্থিতিতে আপনি panic! call করতে পারেন, কিন্তু তখন
আপনি call করা কোডের হয়ে সিদ্ধান্ত নিয়ে ফেলছেন যে পরিস্থিতিটি থেকে সামলে ওঠা যাবে না। আপনি যখন একটি Result মান return করা বেছে
নেন, তখন call করা কোডকে বিকল্প দেন। call করা কোড তার পরিস্থিতির উপযোগী উপায়ে সামলে ওঠার চেষ্টা করা বেছে নিতে পারে, অথবা ঠিক করতে
পারে যে এই ক্ষেত্রে একটি Err মান থেকে সামলে ওঠা যাবে না, তাই সে panic! call করে আপনার recoverable error-কে unrecoverable error-এ
পরিণত করতে পারে। তাই ব্যর্থ হতে পারে এমন function সংজ্ঞায়িত করার সময় Result return করা একটি ভালো ডিফল্ট পছন্দ।
উদাহরণ, prototype কোড আর test-এর মতো পরিস্থিতিতে Result return করার বদলে panic করে এমন কোড লেখা বেশি উপযুক্ত। চলুন দেখি কেন,
তারপর এমন পরিস্থিতি নিয়ে আলোচনা করব, যেখানে compiler বুঝতে পারে না যে ব্যর্থতা অসম্ভব, কিন্তু মানুষ হিসেবে আপনি পারেন। অধ্যায়টি
শেষ হবে library কোডে panic করা হবে কি না, তা ঠিক করার কিছু সাধারণ নির্দেশিকা দিয়ে।
উদাহরণ, prototype কোড আর test
কোনো ধারণা বোঝাতে একটি উদাহরণ লেখার সময় তাতে মজবুত error handling-এর কোডও যোগ করলে উদাহরণটি কম স্পষ্ট হয়ে যেতে পারে। উদাহরণে
এটা বোঝা যায় যে unwrap-এর মতো panic করতে পারে এমন method-এর call হলো আপনার অ্যাপ্লিকেশনে error কীভাবে সামলাতে চান, তার একটি
placeholder (মান বসানোর জন্য রাখা জায়গা), যা আপনার কোডের বাকি অংশ কী করছে তার ভিত্তিতে আলাদা হতে পারে।
একইভাবে, prototype তৈরির সময়, যখন error কীভাবে সামলাবেন তা ঠিক করার জন্য এখনো প্রস্তুত নন, তখন unwrap আর expect method খুব
কাজের। যখন আপনার প্রোগ্রামকে আরও মজবুত করার জন্য প্রস্তুত হবেন, তার জন্য এগুলো আপনার কোডে স্পষ্ট চিহ্ন রেখে যায়।
কোনো test-এ একটি method call ব্যর্থ হলে আপনি চাইবেন পুরো test-টিই ব্যর্থ হোক, এমনকি সেই method পরীক্ষাধীন কার্যকারিতা না হলেও।
panic! দিয়েই যেহেতু একটি test-কে ব্যর্থ হিসেবে চিহ্নিত করা হয়, তাই unwrap বা expect call করাই ঠিক যা হওয়া উচিত।
যখন আপনার কাছে compiler-এর চেয়ে বেশি তথ্য আছে
expect call করা তখনও উপযুক্ত, যখন আপনার কাছে অন্য কোনো যুক্তি আছে, যা নিশ্চিত করে Result-এর একটি Ok মান থাকবে, কিন্তু সেই
যুক্তি compiler বোঝে না। তবু আপনার কাছে একটি Result মান থাকবে, যা সামলাতে হবে: আপনি যে operation call করছেন, তা সাধারণভাবে ব্যর্থ
হওয়ার সম্ভাবনা থেকেই যায়, যদিও আপনার নির্দিষ্ট পরিস্থিতিতে তা যৌক্তিকভাবে অসম্ভব। কোড নিজে খুঁটিয়ে দেখে আপনি যদি নিশ্চিত হতে
পারেন যে কখনো একটি Err variant পাবেন না, তাহলে expect call করে argument-এর লেখায় কেন মনে করেন আপনি কখনো Err variant পাবেন
না, তার কারণ লিখে রাখা সম্পূর্ণ গ্রহণযোগ্য। এখানে একটি উদাহরণ:
fn main() {
use std::net::IpAddr;
let home: IpAddr = "127.0.0.1"
.parse()
.expect("Hardcoded IP address should be valid");
}
আমরা একটি hardcoded string parse করে একটি IpAddr instance তৈরি করছি। আমরা দেখতে পাচ্ছি 127.0.0.1 একটি বৈধ IP address, তাই এখানে
expect ব্যবহার করা গ্রহণযোগ্য। তবে একটি hardcoded, বৈধ string থাকলেও parse method-এর return type বদলায় না: আমরা তবু একটি Result
মান পাই, আর compiler তবু আমাদের দিয়ে Result এমনভাবে সামলাবে, যেন Err variant একটি সম্ভাবনা, কারণ compiler এতটা বুদ্ধিমান নয় যে
দেখবে এই string সবসময় একটি বৈধ IP address। IP address-এর string যদি প্রোগ্রামে hardcoded না হয়ে কোনো ব্যবহারকারীর কাছ থেকে আসত, আর
তাই ব্যর্থতার সম্ভাবনা থাকত, তাহলে আমরা অবশ্যই এর বদলে Result-কে আরও মজবুতভাবে সামলাতে চাইতাম। এই IP address যে hardcoded,
সেই ধারণার উল্লেখ থাকলে ভবিষ্যতে IP address অন্য কোনো উৎস থেকে নিতে হলে আমরা expect-কে আরও ভালো error handling-এর কোডে বদলাতে
উৎসাহিত হব।
error handling-এর নির্দেশিকা
আপনার কোড একটি খারাপ অবস্থায় পৌঁছানোর সম্ভাবনা থাকলে কোডটিকে panic করানোই যুক্তিসংগত। এই প্রেক্ষাপটে খারাপ অবস্থা মানে যখন কোনো ধারণা, নিশ্চয়তা, চুক্তি বা invariant (সবসময় সত্য থাকতে হবে এমন শর্ত) ভেঙে গেছে, যেমন যখন আপনার কোডে অবৈধ মান, পরস্পরবিরোধী মান বা অনুপস্থিত মান পাঠানো হয়—সঙ্গে নিচের এক বা একাধিক শর্ত:
- খারাপ অবস্থাটি অপ্রত্যাশিত, এমন কিছু নয় যা মাঝে মাঝে ঘটবেই, যেমন একজন ব্যবহারকারী ভুল ফরম্যাটে ডেটা দিলেন।
- এই জায়গার পরে আপনার কোডকে প্রতিটি ধাপে সমস্যাটি যাচাই না করে এই খারাপ অবস্থায় না থাকার ওপর নির্ভর করতে হবে।
- আপনার ব্যবহৃত type-গুলোতে এই তথ্য প্রকাশের ভালো কোনো উপায় নেই। আমরা এর মানে কী, তার একটি উদাহরণ অধ্যায় 18-এর “Encoding States and Behavior as Types” অংশে দেখব।
কেউ যদি আপনার কোড call করে এমন মান পাঠায়, যা অর্থবহ নয়, তাহলে সম্ভব হলে একটি error return করাই সবচেয়ে ভালো, যাতে library-র
ব্যবহারকারী ঠিক করতে পারেন সেই ক্ষেত্রে তিনি কী করতে চান। তবে যেসব ক্ষেত্রে চালিয়ে গেলে তা অনিরাপদ বা ক্ষতিকর হতে পারে, সেখানে
সবচেয়ে ভালো সিদ্ধান্ত হতে পারে panic! call করে আপনার library ব্যবহারকারী মানুষটিকে তার কোডের বাগ সম্পর্কে সতর্ক করা, যাতে তিনি
ডেভেলপমেন্টের সময় তা ঠিক করতে পারেন। একইভাবে, আপনি যদি এমন বাইরের কোড call করেন, যা আপনার নিয়ন্ত্রণের বাইরে এবং যা এমন একটি অবৈধ
অবস্থা return করে, যা ঠিক করার কোনো উপায় আপনার নেই, তাহলেও প্রায়ই panic! উপযুক্ত।
তবে ব্যর্থতা যখন প্রত্যাশিত, তখন panic! call করার চেয়ে একটি Result return করা বেশি উপযুক্ত। উদাহরণের মধ্যে আছে একটি parser
(লেখা বিশ্লেষণ করে গঠন বের করে এমন প্রোগ্রাম)-কে ত্রুটিপূর্ণ ডেটা দেওয়া, অথবা একটি HTTP অনুরোধ এমন একটি status return করা, যা বোঝায়
আপনি rate limit (নির্দিষ্ট সময়ে অনুরোধের সর্বোচ্চ সীমা)-এ পৌঁছে গেছেন। এসব ক্ষেত্রে একটি Result return করা বোঝায় যে ব্যর্থতা একটি
প্রত্যাশিত সম্ভাবনা, যা কীভাবে সামলাতে হবে তা call করা কোডকে ঠিক করতে হবে।
আপনার কোড যখন এমন একটি operation করে, যা অবৈধ মান দিয়ে call করা হলে একজন ব্যবহারকারীকে ঝুঁকিতে ফেলতে পারে, তখন আপনার কোডের উচিত
প্রথমে মানগুলো বৈধ কি না যাচাই করা, আর মানগুলো বৈধ না হলে panic করা। এটি মূলত নিরাপত্তার কারণে: অবৈধ ডেটা নিয়ে কাজ করার চেষ্টা
আপনার কোডকে নিরাপত্তা-দুর্বলতার মুখে ফেলতে পারে। এ কারণেই আপনি সীমার বাইরের মেমোরিতে পৌঁছানোর চেষ্টা করলে standard library panic!
call করে: বর্তমান data structure-এর নয় এমন মেমোরিতে পৌঁছানোর চেষ্টা একটি প্রচলিত নিরাপত্তা-সমস্যা। function-এর প্রায়ই চুক্তি
(contract) থাকে: ইনপুট নির্দিষ্ট শর্ত পূরণ করলে তবেই এদের আচরণের নিশ্চয়তা থাকে। চুক্তি লঙ্ঘিত হলে panic করা যুক্তিসংগত, কারণ চুক্তি
লঙ্ঘন সবসময় caller-এর দিকের একটি বাগ বোঝায়, আর এটি এমন ধরনের error নয়, যা আপনি চান call করা কোড স্পষ্টভাবে সামলাক। আসলে call করা
কোডের পক্ষে সামলে ওঠার কোনো যুক্তিসংগত উপায় নেই; call করা প্রোগ্রামারদের কোড ঠিক করতে হবে। একটি function-এর চুক্তি, বিশেষ করে
যখন লঙ্ঘনের ফলে panic ঘটবে, function-টির API ডকুমেন্টেশনে ব্যাখ্যা করা উচিত।
তবে আপনার সব function-এ প্রচুর error যাচাই থাকলে তা লম্বা-চওড়া আর বিরক্তিকর হয়ে যেত। সৌভাগ্যক্রমে, আপনার হয়ে অনেক যাচাই করতে আপনি
Rust-এর type system (ভাষার type-সংক্রান্ত নিয়মের ব্যবস্থা) (এবং তাই compiler-এর করা type checking) ব্যবহার করতে পারেন। আপনার function-এর
parameter হিসেবে যদি একটি নির্দিষ্ট type থাকে, তাহলে আপনি এটা জেনেই আপনার কোডের যুক্তি নিয়ে এগোতে পারেন যে compiler আগেই নিশ্চিত
করেছে আপনার কাছে একটি বৈধ মান আছে। যেমন, আপনার কাছে যদি একটি Option-এর বদলে একটি type থাকে, তাহলে আপনার প্রোগ্রাম কিছুই না-র
বদলে কিছু একটা পাওয়ার আশা করে। তখন আপনার কোডকে Some আর None variant-এর জন্য দুটি ক্ষেত্র সামলাতে হয় না: নিশ্চিতভাবে একটি মান
থাকার শুধু একটি ক্ষেত্রই থাকবে। আপনার function-এ কিছুই না পাঠানোর চেষ্টা করা কোড compile-ই হবে না, তাই runtime-এ আপনার function-কে সেই
ক্ষেত্রটি যাচাই করতে হয় না। আরেকটি উদাহরণ হলো u32-এর মতো একটি unsigned integer type ব্যবহার করা, যা নিশ্চিত করে যে parameter কখনো
ঋণাত্মক নয়।
যাচাইয়ের জন্য নিজস্ব type
আমাদের কাছে একটি বৈধ মান আছে, তা নিশ্চিত করতে Rust-এর type system ব্যবহারের ধারণাটিকে চলুন আরেক ধাপ এগিয়ে নিই এবং যাচাইয়ের জন্য একটি নিজস্ব type তৈরি করা দেখি। অধ্যায় 2-এর সংখ্যা আন্দাজের খেলাটি মনে করুন, যেখানে আমাদের কোড ব্যবহারকারীকে 1 থেকে 100-এর মধ্যে একটি সংখ্যা আন্দাজ করতে বলেছিল। আমাদের গোপন সংখ্যার সঙ্গে মেলানোর আগে আমরা কখনো যাচাই করিনি যে ব্যবহারকারীর আন্দাজ ওই সংখ্যাগুলোর মধ্যে আছে কি না; আমরা শুধু যাচাই করেছিলাম আন্দাজটি ধনাত্মক কি না। এই ক্ষেত্রে পরিণাম খুব গুরুতর ছিল না: আমাদের আউটপুট “Too high” বা “Too low” তবু সঠিক হতো। তবে ব্যবহারকারীকে বৈধ আন্দাজের দিকে নিয়ে যাওয়া, আর ব্যবহারকারী পরিসরের বাইরের সংখ্যা আন্দাজ করলে আর, যেমন, সংখ্যার বদলে অক্ষর টাইপ করলে আলাদা আচরণ করা একটি কাজের উন্নতি হতো।
এটি করার একটি উপায় হলো আন্দাজটিকে শুধু u32-এর বদলে একটি i32 হিসেবে parse করা, যাতে ঋণাত্মক সংখ্যাও সম্ভব হয়, আর তারপর সংখ্যাটি
পরিসরের মধ্যে আছে কি না তার একটি যাচাই যোগ করা, এভাবে:
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;
}
}
}
}
if expression যাচাই করে আমাদের মান পরিসরের বাইরে কি না, ব্যবহারকারীকে সমস্যাটি জানায়, আর loop-এর পরের iteration শুরু করে আরেকটি
আন্দাজ চাইতে continue call করে। if expression-এর পরে আমরা এটা জেনেই guess আর গোপন সংখ্যার তুলনা নিয়ে এগোতে পারি যে guess
1 থেকে 100-এর মধ্যে আছে।
তবে এটি আদর্শ সমাধান নয়: প্রোগ্রামের পক্ষে শুধু 1 থেকে 100-এর মধ্যের মান নিয়ে কাজ করা যদি একেবারে অত্যাবশ্যক হতো, আর এই শর্তযুক্ত অনেক function থাকত, তাহলে প্রতিটি function-এ এমন একটি যাচাই রাখা ক্লান্তিকর হতো (এবং পারফরম্যান্সে প্রভাব ফেলতে পারত)।
বরং আমরা একটি নির্দিষ্ট module-এ একটি নতুন type তৈরি করে, সব জায়গায় যাচাইগুলো পুনরাবৃত্তি না করে, যাচাইগুলো এমন একটি function-এ
রাখতে পারি, যা type-টির একটি instance তৈরি করে। এভাবে function-গুলো তাদের signature-এ নতুন type-টি নিরাপদে ব্যবহার করতে পারে এবং পাওয়া
মানগুলো আত্মবিশ্বাসের সঙ্গে ব্যবহার করতে পারে। Listing 9-13-এ একটি Guess type সংজ্ঞায়িত করার একটি উপায় দেখানো হয়েছে, যা শুধু তখনই
Guess-এর একটি instance তৈরি করবে, যখন new function 1 থেকে 100-এর মধ্যের একটি মান পায়।
#![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
}
}
}
Guess type, যা শুধু 1 থেকে 100-এর মধ্যের মান নিয়েই এগোবেলক্ষ করুন, src/guessing_game.rs-এর এই কোড src/lib.rs-এ mod guessing_game; module ঘোষণা যোগ করার ওপর নির্ভর করে, যা আমরা
এখানে দেখাইনি। এই নতুন module-এর ফাইলের ভেতরে আমরা Guess নামের একটি struct সংজ্ঞায়িত করি, যার value নামের একটি field আছে, যা
একটি i32 রাখে। এখানেই সংখ্যাটি রাখা হবে।
তারপর আমরা Guess-এর ওপর new নামের একটি associated function implement করি, যা Guess মানের instance তৈরি করে। new function
এমনভাবে সংজ্ঞায়িত যে এর i32 type-এর value নামের একটি parameter আছে, আর এটি একটি Guess return করে। new function-এর body-র
কোড value পরীক্ষা করে নিশ্চিত হয় যে এটি 1 থেকে 100-এর মধ্যে আছে। value এই পরীক্ষায় উত্তীর্ণ না হলে আমরা একটি panic! call করি,
যা call করা কোড লেখা প্রোগ্রামারকে সতর্ক করবে যে তার এমন একটি বাগ আছে, যা ঠিক করতে হবে, কারণ এই পরিসরের বাইরের একটি value-সহ
একটি Guess তৈরি করলে Guess::new যে চুক্তির ওপর নির্ভর করছে, তা লঙ্ঘিত হতো। যেসব শর্তে Guess::new panic করতে পারে, তা এর
public API ডকুমেন্টেশনে আলোচনা করা উচিত; অধ্যায় 14-এ আপনার তৈরি API ডকুমেন্টেশনে panic!-এর সম্ভাবনা জানানোর ডকুমেন্টেশন-রীতিগুলো
আমরা দেখব। value পরীক্ষায় উত্তীর্ণ হলে আমরা একটি নতুন Guess তৈরি করি, যার value field value parameter-এর মানে সেট করা, আর
Guess-টি return করি।
এরপর আমরা value নামের একটি method implement করি, যা self-কে borrow করে, যার আর কোনো parameter নেই, এবং যা একটি i32 return
করে। এ ধরনের method-কে কখনো কখনো getter (শুধু একটি field-এর মান ফেরত দেয় এমন method) বলা হয়, কারণ এর উদ্দেশ্য হলো এর field
থেকে কিছু ডেটা নিয়ে তা return করা। এই public method দরকার, কারণ Guess struct-এর value field private। value field-টি private
থাকা জরুরি, যাতে Guess struct ব্যবহারকারী কোড সরাসরি value সেট করতে না পারে: guessing_game module-এর বাইরের কোডকে Guess-এর
একটি instance তৈরি করতে অবশ্যই Guess::new function ব্যবহার করতে হবে, ফলে নিশ্চিত হয় যে কোনো Guess-এর এমন value থাকার উপায়
নেই, যা Guess::new function-এর শর্ত দিয়ে যাচাই করা হয়নি।
যে function-এর parameter আছে বা যা শুধু 1 থেকে 100-এর মধ্যের সংখ্যা return করে, সেটি তখন তার signature-এ ঘোষণা করতে পারে যে এটি
একটি i32-এর বদলে একটি Guess নেয় বা return করে, আর এর body-তে কোনো বাড়তি যাচাই করার দরকার হবে না।
সারসংক্ষেপ
Rust-এর error handling-এর বৈশিষ্ট্যগুলো নকশা করা হয়েছে আরও মজবুত কোড লিখতে আপনাকে সাহায্য করার জন্য। panic! macro সংকেত দেয় যে
আপনার প্রোগ্রাম এমন একটি অবস্থায় আছে, যা এটি সামলাতে পারে না, আর অবৈধ বা ভুল মান নিয়ে এগোনোর চেষ্টা না করে process থামিয়ে দিতে
বলার সুযোগ দেয়। Result enum Rust-এর type system ব্যবহার করে বোঝায় যে operation এমনভাবে ব্যর্থ হতে পারে, যা থেকে আপনার কোড সামলে
উঠতে পারে। আপনার কোড call করা কোডকেও জানাতে আপনি Result ব্যবহার করতে পারেন যে সম্ভাব্য সফলতা বা ব্যর্থতা তাকে সামলাতে হবে। উপযুক্ত
পরিস্থিতিতে panic! আর Result ব্যবহার করলে অনিবার্য সমস্যার মুখে আপনার কোড আরও নির্ভরযোগ্য হবে।
standard library Option আর Result enum-এর সঙ্গে generics কীভাবে কাজে লাগায়, তা দেখার পর এবার আমরা কথা বলব generics কীভাবে
কাজ করে এবং আপনার কোডে কীভাবে সেগুলো ব্যবহার করতে পারেন।