closure
Rust-এর closure (পারিপার্শ্বিক মান ধরে রাখতে পারে এমন নামহীন function) হলো নামহীন function, যা variable-এ রাখা যায় বা অন্য function-এ argument হিসেবে পাঠানো যায়। এক জায়গায় closure তৈরি করে অন্য জায়গায় call করে ভিন্ন প্রেক্ষাপটে একে মূল্যায়ন করা যায়। function-এর মতো নয়, closure যে scope-এ সংজ্ঞায়িত হয় সেখান থেকে মান capture করতে (ধরে রাখতে) পারে। closure-এর এই বৈশিষ্ট্যগুলো কীভাবে কোডের পুনর্ব্যবহার আর আচরণ নিজের মতো সাজানো সম্ভব করে, তা আমরা দেখাব।
environment capture করা
প্রথমে দেখব কীভাবে closure ব্যবহার করে যে environment (পারিপার্শ্বিক পরিবেশ)-এ এটি সংজ্ঞায়িত হয়েছে সেখান থেকে পরে ব্যবহারের জন্য মান capture করা যায়। পরিস্থিতিটা এমন: প্রচারণার অংশ হিসেবে আমাদের T-shirt কোম্পানি মাঝে মাঝে mailing list-এর কাউকে একটি বিশেষ, সীমিত সংস্করণের shirt উপহার দেয়। mailing list-এর মানুষেরা চাইলে তাদের profile-এ প্রিয় রং যোগ করতে পারে। বিনামূল্যের shirt-এর জন্য বাছাই করা ব্যক্তির প্রিয় রং সেট করা থাকলে সে সেই রঙের shirt পায়। আর প্রিয় রং উল্লেখ না করলে কোম্পানির কাছে এই মুহূর্তে যে রঙের shirt সবচেয়ে বেশি আছে, সেটি পায়।
এটি implement করার অনেক উপায় আছে। এই উদাহরণে আমরা ShirtColor নামের একটি enum ব্যবহার করব, যার variant হলো Red আর Blue (সরলতার
জন্য রঙের সংখ্যা সীমিত রাখা হয়েছে)। কোম্পানির মজুত বোঝাতে আমরা একটি Inventory struct ব্যবহার করি, যার shirts নামের একটি field-এ
একটি Vec<ShirtColor> থাকে, যা এই মুহূর্তে মজুত থাকা shirt-এর রংগুলো বোঝায়। Inventory-এর ওপর সংজ্ঞায়িত giveaway method
বিনামূল্যের shirt বিজয়ীর ঐচ্ছিক রঙের পছন্দ নেয়, এবং ব্যক্তিটি যে রঙের shirt পাবে তা return করে। এই ব্যবস্থাটি Listing 13-1-এ দেখানো
হয়েছে।
#[derive(Debug, PartialEq, Copy, Clone)]
enum ShirtColor {
Red,
Blue,
}
struct Inventory {
shirts: Vec<ShirtColor>,
}
impl Inventory {
fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
user_preference.unwrap_or_else(|| self.most_stocked())
}
fn most_stocked(&self) -> ShirtColor {
let mut num_red = 0;
let mut num_blue = 0;
for color in &self.shirts {
match color {
ShirtColor::Red => num_red += 1,
ShirtColor::Blue => num_blue += 1,
}
}
if num_red > num_blue {
ShirtColor::Red
} else {
ShirtColor::Blue
}
}
}
fn main() {
let store = Inventory {
shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
};
let user_pref1 = Some(ShirtColor::Red);
let giveaway1 = store.giveaway(user_pref1);
println!(
"The user with preference {:?} gets {:?}",
user_pref1, giveaway1
);
let user_pref2 = None;
let giveaway2 = store.giveaway(user_pref2);
println!(
"The user with preference {:?} gets {:?}",
user_pref2, giveaway2
);
}
main-এ সংজ্ঞায়িত store-এ এই সীমিত সংস্করণের প্রচারণায় বিতরণের জন্য দুটি নীল আর একটি লাল shirt বাকি আছে। আমরা লাল shirt পছন্দ করা
একজন ব্যবহারকারী আর কোনো পছন্দ নেই এমন একজন ব্যবহারকারীর জন্য giveaway method call করি।
আবারও বলি, এই কোড অনেকভাবে implement করা যেত, আর এখানে closure-এর দিকে মনোযোগ রাখতে আমরা আপনার আগে শেখা ধারণাগুলোতেই সীমাবদ্ধ থেকেছি,
শুধু giveaway method-এর body ছাড়া, যেখানে একটি closure ব্যবহার করা হয়েছে। giveaway method-এ আমরা ব্যবহারকারীর পছন্দ
Option<ShirtColor> type-এর parameter হিসেবে পাই এবং user_preference-এর ওপর unwrap_or_else method call করি। Option<T>-এর ওপর
unwrap_or_else method standard library-তে সংজ্ঞায়িত। এটি একটি argument নেয়: কোনো argument ছাড়া একটি
closure, যা একটি T মান return করে (Option<T>-এর Some variant-এ যে type রাখা থাকে সেই একই type, এই ক্ষেত্রে ShirtColor)।
Option<T> যদি Some variant হয়, তাহলে unwrap_or_else Some-এর ভেতরের মানটি return করে। Option<T> যদি None variant হয়, তাহলে
unwrap_or_else closure-টি call করে এবং closure-এর return করা মানটি return করে।
unwrap_or_else-এর argument হিসেবে আমরা closure expression || self.most_stocked() দিই। এটি এমন একটি closure যা নিজে কোনো parameter
নেয় না (closure-এর parameter থাকলে সেগুলো দুটি খাড়া দাগের মাঝে থাকত)। closure-এর body self.most_stocked() call করে। closure-টি আমরা
এখানে সংজ্ঞায়িত করছি, আর ফলাফল দরকার হলে unwrap_or_else-এর implementation পরে closure-টি মূল্যায়ন করবে।
এই কোড চালালে এই output আসে:
$ cargo run
Compiling shirt-company v0.1.0 (file:///projects/shirt-company)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/shirt-company`
The user with preference Some(Red) gets Red
The user with preference None gets Blue
এখানে একটি মজার দিক হলো, আমরা এমন একটি closure পাঠিয়েছি যা বর্তমান Inventory instance-এর ওপর self.most_stocked() call করে।
আমাদের সংজ্ঞায়িত Inventory বা ShirtColor type, বা এই পরিস্থিতিতে আমরা যে logic ব্যবহার করতে চাই, সে সম্পর্কে standard library-র কিছু
জানার দরকার হয়নি। closure-টি self Inventory instance-এর একটি immutable reference capture করে এবং আমাদের দেওয়া কোডের সঙ্গে সেটি
unwrap_or_else method-এ পাঠায়। অন্যদিকে function এভাবে তার environment capture করতে পারে না।
closure-এর type অনুমান ও annotate করা
function আর closure-এর মধ্যে আরও পার্থক্য আছে। fn function-এর মতো closure-এ সাধারণত parameter বা return মানের type annotate করতে হয়
না। function-এ type annotation বাধ্যতামূলক, কারণ type-গুলো আপনার ব্যবহারকারীদের কাছে প্রকাশিত একটি স্পষ্ট interface-এর অংশ। একটি
function কোন type-এর মান ব্যবহার ও return করে সে বিষয়ে সবাই যাতে একমত থাকে, তা নিশ্চিত করতে এই interface কঠোরভাবে সংজ্ঞায়িত করা
গুরুত্বপূর্ণ। অন্যদিকে closure এভাবে কোনো প্রকাশিত interface-এ ব্যবহৃত হয় না: এগুলো variable-এ রাখা হয়, এবং নাম না দিয়ে ও আমাদের
library-র ব্যবহারকারীদের কাছে প্রকাশ না করেই ব্যবহার করা হয়।
closure সাধারণত ছোট হয় এবং যেকোনো পরিস্থিতিতে নয়, বরং একটি সংকীর্ণ প্রেক্ষাপটেই প্রাসঙ্গিক থাকে। এই সীমিত প্রেক্ষাপটে compiler parameter আর return মানের type অনুমান করতে পারে, ঠিক যেভাবে বেশিরভাগ variable-এর type অনুমান করতে পারে (তবে বিরল কিছু ক্ষেত্রে compiler-এরও closure-এর type annotation দরকার হয়)।
variable-এর মতোই, প্রয়োজনের চেয়ে বেশি শব্দবহুল হওয়ার বিনিময়ে স্পষ্টতা বাড়াতে চাইলে আমরা type annotation যোগ করতে পারি। একটি closure-এর type annotate করলে দেখতে Listing 13-2-এর সংজ্ঞার মতো হবে। এই উদাহরণে Listing 13-1-এর মতো যেখানে argument হিসেবে পাঠাচ্ছি সেখানেই closure সংজ্ঞায়িত না করে আমরা একটি closure সংজ্ঞায়িত করে variable-এ রাখছি।
use std::thread;
use std::time::Duration;
fn generate_workout(intensity: u32, random_number: u32) {
let expensive_closure = |num: u32| -> u32 {
println!("calculating slowly...");
thread::sleep(Duration::from_secs(2));
num
};
if intensity < 25 {
println!("Today, do {} pushups!", expensive_closure(intensity));
println!("Next, do {} situps!", expensive_closure(intensity));
} else {
if random_number == 3 {
println!("Take a break today! Remember to stay hydrated!");
} else {
println!(
"Today, run for {} minutes!",
expensive_closure(intensity)
);
}
}
}
fn main() {
let simulated_user_specified_value = 10;
let simulated_random_number = 7;
generate_workout(simulated_user_specified_value, simulated_random_number);
}
type annotation যোগ করলে closure-এর syntax function-এর syntax-এর আরও কাছাকাছি দেখায়। তুলনার জন্য এখানে আমরা একটি function সংজ্ঞায়িত করেছি যা তার parameter-এর সঙ্গে 1 যোগ করে, আর একই আচরণের একটি closure। প্রাসঙ্গিক অংশগুলো এক সারিতে আনতে কিছু space যোগ করেছি। এতে বোঝা যায় যে closure-এর syntax function-এর syntax-এর মতোই, শুধু খাড়া দাগের ব্যবহার আর কতটা syntax ঐচ্ছিক, এই দুটি ছাড়া:
fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;
প্রথম লাইনে একটি function-এর সংজ্ঞা, আর দ্বিতীয় লাইনে পুরোপুরি annotate করা একটি closure-এর সংজ্ঞা। তৃতীয় লাইনে closure-এর সংজ্ঞা
থেকে type annotation সরিয়ে দিয়েছি। চতুর্থ লাইনে bracket সরিয়ে দিয়েছি, যা ঐচ্ছিক, কারণ closure-এর body-তে মাত্র একটি expression।
এগুলো সবই বৈধ সংজ্ঞা, যা call করলে একই আচরণ করবে। add_one_v3 আর add_one_v4 লাইন compile হতে হলে closure-গুলোকে মূল্যায়ন করতে হবে,
কারণ type অনুমান হবে তাদের ব্যবহার থেকে। এটা let v = Vec::new();-এর মতো, যেখানে Rust-কে type অনুমান করতে হলে হয় type annotation
লাগে, নয়তো Vec-এ কোনো type-এর মান ঢোকাতে হয়।
closure-এর সংজ্ঞার ক্ষেত্রে compiler এর প্রতিটি parameter আর return মানের জন্য একটি করে concrete type অনুমান করবে। যেমন, Listing 13-3-এ
একটি ছোট closure-এর সংজ্ঞা দেখানো হয়েছে, যা parameter হিসেবে পাওয়া মানটিই return করে। এই উদাহরণের উদ্দেশ্য ছাড়া closure-টি খুব একটা
কাজের নয়। খেয়াল করুন, সংজ্ঞায় আমরা কোনো type annotation যোগ করিনি। type annotation না থাকায় যেকোনো type দিয়ে closure-টি call করা যায়,
এখানে প্রথমবার আমরা String দিয়ে তা করেছি। তারপর integer দিয়ে example_closure call করার চেষ্টা করলে error পাব।
fn main() {
let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);
}
compiler আমাদের এই error দেয়:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
error[E0308]: mismatched types
--> src/main.rs:5:29
|
5 | let n = example_closure(5);
| --------------- ^ expected `String`, found integer
| |
| arguments to this function are incorrect
|
note: expected because the closure was earlier called with an argument of type `String`
--> src/main.rs:4:29
|
4 | let s = example_closure(String::from("hello"));
| --------------- ^^^^^^^^^^^^^^^^^^^^^ expected because this argument is of type `String`
| |
| in this closure call
note: closure parameter defined here
--> src/main.rs:2:28
|
2 | let example_closure = |x| x;
| ^
help: try using a conversion method
|
5 | let n = example_closure(5.to_string());
| ++++++++++++
For more information about this error, try `rustc --explain E0308`.
error: could not compile `closure-example` (bin "closure-example") due to 1 previous error
প্রথমবার String মান দিয়ে example_closure call করলে compiler x-এর type আর closure-এর return type String বলে অনুমান করে। তারপর
সেই type-গুলো example_closure-এর closure-এ আটকে যায়, আর পরের বার একই closure-এ ভিন্ন type ব্যবহার করার চেষ্টা করলে type error পাই।
reference capture করা বা ownership সরিয়ে নেওয়া
closure তার environment থেকে তিনভাবে মান capture করতে পারে, যা সরাসরি function-এর parameter নেওয়ার তিনটি উপায়ের সঙ্গে মেলে: immutable-ভাবে borrow করা, mutable-ভাবে borrow করা, আর ownership নেওয়া। capture করা মানগুলো নিয়ে function-এর body কী করে, তার ওপর ভিত্তি করে closure ঠিক করবে এগুলোর কোনটি ব্যবহার করবে।
Listing 13-4-এ আমরা এমন একটি closure সংজ্ঞায়িত করি যা list নামের vector-এর একটি immutable reference capture করে, কারণ মান print করতে এর
শুধু একটি immutable reference দরকার।
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let only_borrows = || println!("From closure: {list:?}");
println!("Before calling closure: {list:?}");
only_borrows();
println!("After calling closure: {list:?}");
}
এই উদাহরণ এটাও দেখায় যে একটি variable একটি closure-এর সংজ্ঞার সঙ্গে bind হতে পারে, আর পরে variable-এর নাম আর বন্ধনী ব্যবহার করে closure-টি call করা যায়, যেন variable-এর নামটিই একটি function-এর নাম।
একই সময়ে list-এর একাধিক immutable reference থাকতে পারে বলে closure-এর সংজ্ঞার আগের কোড থেকে, closure-এর সংজ্ঞার পরে কিন্তু
closure call করার আগে, আর closure call করার পরে, সব জায়গা থেকেই list ব্যবহার করা যায়। এই কোড compile হয়, চলে, এবং print করে:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
Before calling closure: [1, 2, 3]
From closure: [1, 2, 3]
After calling closure: [1, 2, 3]
এরপর Listing 13-5-এ আমরা closure-এর body বদলে দিই, যাতে এটি list vector-এ একটি উপাদান যোগ করে। closure-টি এখন একটি mutable reference
capture করে।
fn main() {
let mut list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let mut borrows_mutably = || list.push(7);
borrows_mutably();
println!("After calling closure: {list:?}");
}
এই কোড compile হয়, চলে, এবং print করে:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
After calling closure: [1, 2, 3, 7]
খেয়াল করুন, borrows_mutably closure-এর সংজ্ঞা আর call-এর মাঝে এখন আর কোনো println! নেই: borrows_mutably সংজ্ঞায়িত হওয়ার সময় এটি
list-এর একটি mutable reference capture করে। closure call করার পর আমরা আর closure-টি ব্যবহার করি না, তাই mutable borrow শেষ হয়ে
যায়। closure-এর সংজ্ঞা আর closure call-এর মাঝে print করার জন্য immutable borrow অনুমোদিত নয়, কারণ mutable borrow থাকলে অন্য কোনো
borrow অনুমোদিত নয়। সেখানে একটি println! যোগ করে দেখুন কোন error message পান!
closure-এর body-র আসলে ownership দরকার না হলেও আপনি যদি closure-কে environment-এ ব্যবহৃত মানগুলোর ownership নিতে বাধ্য করতে চান, তাহলে
parameter তালিকার আগে move keyword ব্যবহার করতে পারেন।
এই কৌশল মূলত কাজে লাগে যখন একটি নতুন thread-এ closure পাঠিয়ে ডেটা সরিয়ে নিতে হয়, যাতে ডেটার owner হয় নতুন thread। thread কী এবং কেন
ব্যবহার করবেন, তা বিস্তারিত আলোচনা করব অধ্যায় 16-এ concurrency (একসঙ্গে একাধিক কাজ সামলানো) নিয়ে কথা বলার সময়, তবে আপাতত চলুন সংক্ষেপে
দেখি কীভাবে move keyword লাগে এমন একটি closure দিয়ে নতুন thread চালু করা যায়। Listing 13-6-এ Listing 13-4-কে বদলে main thread-এর বদলে
একটি নতুন thread-এ vector print করানো হয়েছে।
use std::thread;
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
thread::spawn(move || println!("From thread: {list:?}"))
.join()
.unwrap();
}
list-এর ownership নিতে বাধ্য করতে move ব্যবহার করাআমরা একটি নতুন thread চালু করি, আর argument হিসেবে thread-কে চালানোর জন্য একটি closure দিই। closure-এর body তালিকাটি print করে। Listing
13-4-এ closure শুধু একটি immutable reference দিয়ে list capture করেছিল, কারণ print করতে list-এর ওপর ওইটুকু প্রবেশাধিকারই যথেষ্ট। এই
উদাহরণে closure-এর body-র এখনো শুধু একটি immutable reference দরকার হলেও closure-এর সংজ্ঞার শুরুতে move keyword বসিয়ে আমাদের বলে দিতে
হবে যে list-কে closure-এর ভেতরে সরিয়ে নিতে হবে। নতুন thread-এ join call করার আগে main thread যদি আরও কাজ করত, তাহলে নতুন thread
main thread-এর বাকি অংশ শেষ হওয়ার আগেই শেষ হয়ে যেতে পারত, অথবা main thread আগে শেষ হতে পারত। main thread যদি list-এর ownership রেখে
দিত কিন্তু নতুন thread-এর আগে শেষ হয়ে list drop করত, তাহলে thread-এর immutable reference অবৈধ হয়ে যেত। তাই compiler চায় list-কে
নতুন thread-এ দেওয়া closure-এর ভেতরে সরিয়ে নেওয়া হোক, যাতে reference বৈধ থাকে। move keyword সরিয়ে দিয়ে, বা closure সংজ্ঞায়িত করার
পরে main thread-এ list ব্যবহার করে দেখুন কোন compiler error পান!
capture করা মান closure থেকে বের করে নেওয়া
closure যে environment-এ সংজ্ঞায়িত হয়েছে সেখান থেকে একবার কোনো মানের reference বা ownership capture করে ফেললে (যা ঠিক করে কী, যদি কিছু থাকে, closure-এর ভেতরে সরানো হবে), closure-এর body-র কোড ঠিক করে পরে closure মূল্যায়নের সময় reference বা মানগুলোর কী হবে (যা ঠিক করে কী, যদি কিছু থাকে, closure-এর বাইরে সরানো হবে)।
একটি closure-এর body এর যেকোনোটি করতে পারে: capture করা মান closure থেকে বাইরে সরিয়ে নেওয়া, capture করা মান পরিবর্তন করা, মানটি সরানো বা পরিবর্তন কোনোটিই না করা, অথবা শুরু থেকেই environment থেকে কিছুই capture না করা।
closure কীভাবে environment থেকে মান capture করে ও সামলায়, তা ঠিক করে closure কোন trait implement করবে, আর trait-এর মাধ্যমেই function
ও struct বলে দিতে পারে তারা কোন ধরনের closure ব্যবহার করতে পারে। closure-এর body মানগুলো কীভাবে সামলায় তার ওপর নির্ভর করে closure
স্বয়ংক্রিয়ভাবে এই Fn trait-গুলোর একটি, দুটি বা তিনটিই, যোগ হওয়ার ধাঁচে, implement করবে:
FnOnceপ্রযোজ্য সেই closure-এর ক্ষেত্রে যা একবার call করা যায়। সব closure অন্তত এই trait implement করে, কারণ সব closure call করা যায়। যে closure capture করা মান তার body থেকে বাইরে সরিয়ে নেয়, সেটি শুধুFnOnceimplement করবে, অন্য কোনোFntrait নয়, কারণ এটি মাত্র একবার call করা যায়।FnMutপ্রযোজ্য সেই closure-এর ক্ষেত্রে যা capture করা মান তার body থেকে বাইরে সরায় না, কিন্তু capture করা মান পরিবর্তন করতে পারে। এই closure-গুলো একাধিকবার call করা যায়।Fnপ্রযোজ্য সেই closure-এর ক্ষেত্রে যা capture করা মান তার body থেকে বাইরে সরায় না এবং capture করা মান পরিবর্তনও করে না, আর সেই closure-এর ক্ষেত্রেও যা environment থেকে কিছুই capture করে না। এই closure-গুলো environment পরিবর্তন না করেই একাধিকবার call করা যায়, যা গুরুত্বপূর্ণ, যেমন একই closure একসঙ্গে একাধিকবার call করার ক্ষেত্রে।
Listing 13-1-এ ব্যবহার করা Option<T>-এর unwrap_or_else method-এর সংজ্ঞাটি দেখা যাক:
impl<T> Option<T> {
pub fn unwrap_or_else<F>(self, f: F) -> T
where
F: FnOnce() -> T
{
match self {
Some(x) => x,
None => f(),
}
}
}
মনে করুন, T হলো generic type, যা একটি Option-এর Some variant-এ থাকা মানের type বোঝায়। সেই T type-ই unwrap_or_else function-এর
return type: যেমন, একটি Option<String>-এর ওপর unwrap_or_else call করা কোড একটি String পাবে।
এরপর খেয়াল করুন, unwrap_or_else function-এর একটি বাড়তি generic type parameter F আছে। F type হলো f নামের parameter-এর type, যা
unwrap_or_else call করার সময় আমাদের দেওয়া closure।
generic type F-এর ওপর দেওয়া trait bound হলো FnOnce() -> T, অর্থাৎ F-কে একবার call করা যেতে হবে, কোনো argument নেবে না, এবং একটি T
return করবে। trait bound-এ FnOnce ব্যবহার করা এই শর্ত প্রকাশ করে যে unwrap_or_else f-কে একবারের বেশি call করবে না।
unwrap_or_else-এর body-তে দেখতে পাই, Option যদি Some হয়, তাহলে f call হবে না। Option যদি None হয়, তাহলে f একবার call হবে।
সব closure যেহেতু FnOnce implement করে, তাই unwrap_or_else তিন ধরনের closure-ই গ্রহণ করে এবং যতটা সম্ভব নমনীয়।
Note: আমরা যা করতে চাই তাতে যদি environment থেকে কোনো মান capture করার দরকার না হয়, তাহলে যেখানে Fn trait-গুলোর কোনো একটি implement
করে এমন কিছু লাগে, সেখানে closure-এর বদলে একটি function-এর নাম ব্যবহার করতে পারি। যেমন, একটি Option<Vec<T>> মানের ওপর
unwrap_or_else(Vec::new) call করে মানটি None হলে একটি নতুন, খালি vector পেতে পারি। compiler একটি function-এর সংজ্ঞার জন্য Fn
trait-গুলোর মধ্যে যেটি প্রযোজ্য, সেটি স্বয়ংক্রিয়ভাবে implement করে।
এবার slice-এর ওপর সংজ্ঞায়িত standard library-র method sort_by_key দেখা যাক, যাতে বোঝা যায় এটি unwrap_or_else থেকে কীভাবে আলাদা এবং
কেন sort_by_key trait bound-এ FnOnce-এর বদলে FnMut ব্যবহার করে। closure-টি একটি argument পায়, যা slice-এর বিবেচনাধীন বর্তমান
item-এর একটি reference, এবং এটি K type-এর এমন একটি মান return করে যা ক্রমানুসারে সাজানো যায়। প্রতিটি item-এর নির্দিষ্ট কোনো বৈশিষ্ট্য
অনুযায়ী একটি slice সাজাতে চাইলে এই function কাজে লাগে। Listing 13-7-এ আমাদের কাছে Rectangle instance-এর একটি তালিকা আছে, আর আমরা
sort_by_key ব্যবহার করে সেগুলোকে তাদের width বৈশিষ্ট্য অনুযায়ী কম থেকে বেশি ক্রমে সাজাই।
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
list.sort_by_key(|r| r.width);
println!("{list:#?}");
}
sort_by_key ব্যবহার করাএই কোড print করে:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s
Running `target/debug/rectangles`
[
Rectangle {
width: 3,
height: 5,
},
Rectangle {
width: 7,
height: 12,
},
Rectangle {
width: 10,
height: 1,
},
]
sort_by_key-কে একটি FnMut closure নেওয়ার মতো করে সংজ্ঞায়িত করার কারণ হলো এটি closure-টি একাধিকবার call করে: slice-এর প্রতিটি item-এর
জন্য একবার করে। |r| r.width closure তার environment থেকে কিছু capture, পরিবর্তন বা বাইরে সরায় না, তাই এটি trait bound-এর শর্ত পূরণ করে।
বিপরীতে, Listing 13-8-এ এমন একটি closure-এর উদাহরণ দেখানো হয়েছে যা শুধু FnOnce trait implement করে, কারণ এটি environment থেকে একটি মান
বাইরে সরিয়ে নেয়। compiler আমাদের এই closure sort_by_key-এর সঙ্গে ব্যবহার করতে দেবে না।
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut sort_operations = vec![];
let value = String::from("closure called");
list.sort_by_key(|r| {
sort_operations.push(value);
r.width
});
println!("{list:#?}");
}
sort_by_key-এর সঙ্গে একটি FnOnce closure ব্যবহারের চেষ্টাlist সাজানোর সময় sort_by_key কতবার closure call করে তা গোনার এটি একটি কৃত্রিম, জটিল (এবং কাজ করে না এমন) চেষ্টা। এই কোড গোনার কাজটি
করতে চায় value—closure-এর environment-এর একটি String—কে sort_operations vector-এ push করে। closure-টি value capture করে, তারপর
value-এর ownership sort_operations vector-এ হস্তান্তর করে value-কে closure থেকে বাইরে সরিয়ে নেয়। এই closure একবার call করা যায়;
দ্বিতীয়বার call করার চেষ্টা কাজ করবে না, কারণ তখন sort_operations-এ আবার push করার জন্য environment-এ আর value থাকবে না! তাই এই
closure শুধু FnOnce implement করে। এই কোড compile করার চেষ্টা করলে আমরা এই error পাই যে value-কে closure থেকে বাইরে সরানো যাবে না,
কারণ closure-কে FnMut implement করতে হবে:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
error[E0507]: cannot move out of `value`, a captured variable in an `FnMut` closure
--> src/main.rs:18:30
|
15 | let value = String::from("closure called");
| ----- ------------------------------ move occurs because `value` has type `String`, which does not implement the `Copy` trait
| |
| captured outer variable
16 |
17 | list.sort_by_key(|r| {
| --- captured by this `FnMut` closure
18 | sort_operations.push(value);
| ^^^^^ `value` is moved here
|
help: consider cloning the value if the performance cost is acceptable
|
18 | sort_operations.push(value.clone());
| ++++++++
For more information about this error, try `rustc --explain E0507`.
error: could not compile `rectangles` (bin "rectangles") due to 1 previous error
error-টি closure-এর body-র সেই লাইন দেখিয়ে দেয় যা value-কে environment থেকে বাইরে সরায়। এটি ঠিক করতে closure-এর body এমনভাবে বদলাতে
হবে যাতে এটি environment থেকে কোনো মান বাইরে না সরায়। environment-এ একটি counter রেখে closure-এর body-তে তার মান বাড়ানো closure কতবার call
হয়েছে তা গোনার আরও সোজাসাপ্টা উপায়। Listing 13-9-এর closure sort_by_key-এর সঙ্গে কাজ করে, কারণ এটি শুধু num_sort_operations counter-এর
একটি mutable reference capture করছে, তাই একাধিকবার call করা যায়।
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut num_sort_operations = 0;
list.sort_by_key(|r| {
num_sort_operations += 1;
r.width
});
println!("{list:#?}, sorted in {num_sort_operations} operations");
}
sort_by_key-এর সঙ্গে একটি FnMut closure ব্যবহার করা অনুমোদিত।সংক্ষেপে, closure ব্যবহার করে এমন function বা type সংজ্ঞায়িত বা ব্যবহারের সময় Fn trait-গুলো গুরুত্বপূর্ণ। পরের অংশে আমরা iterator নিয়ে
আলোচনা করব। iterator-এর অনেক method closure argument নেয়, তাই এগোনোর সময় closure-এর এই খুঁটিনাটিগুলো মনে রাখবেন!