স্ট্রাক্ট
স্ট্রাক্ট হলো কাস্টম ডেটা টাইপ, যা দিয়ে আপনি একাধিক সম্পর্কিত মানকে একসাথে একটি নাম দেওয়া ও প্যাকেজ করার সুযোগ পান।
একটি স্ট্রাক্ট ডিফাইন করতে struct কিওয়ার্ডটি ব্যবহার করুন, তারপর একটি নাম এবং দ্বিতীয় বন্ধনী, যার ভেতরে ফিল্ডগুলোর নাম ও টাইপ থাকবে:
#[derive(Drop)]
struct User {
active: bool,
username: ByteArray,
email: ByteArray,
sign_in_count: u64,
}
একটি struct-এর ইনস্ট্যান্স তৈরি করতে struct-এর নাম উল্লেখ করুন এবং ফিল্ডগুলোর কী-ভ্যালু জোড়া দিয়ে দ্বিতীয় বন্ধনী ব্যবহার করুন।
let user = User {
active: true, username: "someusername123", email: "someone@example.com", sign_in_count: 1
};
একটি মিউটেবল struct ইনস্ট্যান্সের ফিল্ড পড়তে বা বদলাতে ডট নোটেশন ব্যবহার করুন।
let mut user = User {
active: true, username: "someusername123", email: "someone@example.com", sign_in_count: 1
};
user.email = "anotheremail@example.com";
ওনারশিপ
Cairo-তে মান ইমিউটেবল, এবং এই বৈশিষ্ট্যের কারণে একই মানে অনেক ভ্যারিয়েবল নির্দেশ করলেও মানটি নিজে স্থির ও অপরিবর্তিত থাকে।
একটি ভ্যারিয়েবলের ওনার হলো সেই কোড, যা ওই ভ্যারিয়েবল পড়তে পারে (আর মিউটেবল হলে লিখতেও পারে)।
Cairo-তে ওনারশিপের নিয়মগুলো:
- Cairo-তে প্রতিটি ভ্যারিয়েবলের একটি ওনার থাকে।
- একসাথে একজনই ওনার থাকতে পারে।
- ওনার স্কোপের বাইরে চলে গেলে ভ্যারিয়েবলটি ধ্বংস হয়ে যায়।
স্কোপ হলো একটি প্রোগ্রামের ভেতরের সেই পরিসর, যেখানে একটি ভ্যারিয়েবল বৈধ থাকে।
fn main() {
// `x` is not valid here, it has not been declared yet
let x: u32 = 3; // `x` is declared, it is valid from this point forward
// do stuff with `x`
} // this scope ended here, `x` goes out of scope and is no longer valid
কোনো ভ্যারিয়েবল স্কোপের বাইরে চলে গেলে সেটি ধ্বংস হয়ে যায়, যা নিশ্চিত করে যে সংশ্লিষ্ট রিসোর্সটি সঠিকভাবে মুক্ত করা হয়।
এটি করা হয় Drop ট্রেইট ইমপ্লিমেন্ট বা ডিরাইভ করে, যা কম্পাইলারকে জানায় যে টাইপটি আর কাজে না লাগলে নিরাপদে ধ্বংস করা যায়।
#[derive(Drop)]
struct A {}
fn main() {
A {}; // this value can be destroyed after going out of scope
}
এই মুহূর্তে Drop ইমপ্লিমেন্টেশন সব টাইপের জন্যই ডিরাইভ করা যায়, শুধু ডিকশনারি (Felt252Dict) এবং ডিকশনারি-সহ টাইপগুলো ছাড়া।
একটি মান মুভ করাও যায়, যা ঘটে যখন একটি মান অন্য একটি ফাংশনে পাঠানো হয়। তখন যে ভ্যারিয়েবলটি ওই মানকে নির্দেশ করছিল সেটি ধ্বংস হয়ে যায় (ফলে ভ্যারিয়েবলটি অকেজো হয়ে পড়ে) এবং একই মান ধরে রাখার জন্য একটি নতুন ভ্যারিয়েবল তৈরি হয়।
fn foo(num: u32) {
// do something with p
}
fn main() {
let num: u32 = 10;
foo(num);
// ownership of `num` was moved into `foo` and is thus no longer valid in this scope
}
মান রিটার্ন করাও সেগুলোকে মুভ করার সমান।
নিচের উদাহরণটি এমন একটি ফাংশন দেখায়, যা কিছু মান রিটার্ন করে:
#[derive(Drop)]
struct A {}
fn main() {
// main now owns a1
let a1 = gives_ownership();
// a2 comes into scope
let a2 = A {};
// a2 is moved into takes_and_gives_back, which also moves its return value into a3
let a3 = takes_and_gives_back(a2);
} // Here, a3 and a1 go out of scope and are dropped. a2 was moved, so nothing happens.
// Moves its return value into the function that calls it
fn gives_ownership() -> A {
let some_a = A {};
some_a
}
// This function takes an instance some_a of A and returns it
fn takes_and_gives_back(some_a: A) -> A {
some_a
}
যেহেতু মুভ হওয়ার পর একটি ভ্যারিয়েবল ধ্বংস হয়ে যায়, তাই কম্পাইলার আমাদেরকে সেটি পরে আবার ব্যবহার করতে দেয় না।
#[derive(Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(p: Point) {
// do something with p
}
fn main() {
let p = Point { x: 5, y: 10 };
foo(p);
foo(p); // compiler error: Variable was previously moved.
}
এই ক্ষেত্রে আমরা একই মান (অর্থাৎ p ভ্যারিয়েবলের Point স্ট্রাক্ট) দুটি ফাংশন কলে-ই পাঠাতে চেষ্টা করছি।
প্রথমবার foo ফাংশনে ভ্যারিয়েবলটি পাঠানোর পরেই সেটি আর ব্যবহারযোগ্য থাকে না।
এটি সমাধানের একটি উপায় হলো আমাদের স্ট্রাক্টে Copy ট্রেইট ডিরাইভ করা, যা বদলে দেবে একটি Copy ভ্যারিয়েবল ফাংশনে পাঠালে কী হয়: তখন আর মানটি মুভ হবে না, বরং একই মানকে নির্দেশ করা একটি নতুন ভ্যারিয়েবল তৈরি হবে।
এটি একটি ফ্রি অপারেশন, কারণ ভ্যারিয়েবল হলো Cairo-র একটি অ্যাবস্ট্রাকশন আর মান সবসময় ইমিউটেবল।
আপনার টাইপে Copy ট্রেইট ইমপ্লিমেন্ট করতে টাইপের ডেফিনিশনে #[derive(Copy)] অ্যানোটেশনটি যোগ করুন।
#[derive(Copy, Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(p: Point) {
// do something with p
}
fn main() {
let p = Point { x: 5, y: 10 };
foo(p);
foo(p); // this now works
}
রেফারেন্স ও স্ন্যাপশট
কোনো মান ধ্বংস বা মুভ না করেই সেটি পাঠানোর জন্য Cairo-তে দুটি ফিচার আছে, যাদের বলা হয় references ও snapshots।
স্ন্যাপশট কোনো একটি নির্দিষ্ট সময়ে একটি মানের একটি ইমিউটেবল "ভিউ" দেয়, যা দিয়ে আপনি ভ্যারিয়েবলের স্টেট অ্যাক্সেস করার সময়ও তার ওনারশিপ ধরে রাখতে পারেন।
ভ্যারিয়েবলে যেকোনো পরিবর্তন একটি নতুন মেমরি সেল তৈরি করে, ফলে স্ন্যাপশটের ভিউ অপরিবর্তিত থাকে।
একটি স্ন্যাপশট তৈরি করতে শুধু ভ্যারিয়েবল ইনস্ট্যান্সের আগে @ বসান।
// this function takes in a snapshot using `@` with the data-type
fn get_len(arr: @Array<u128>) -> u32 { //
arr.len()
}
fn foo(arr: Array<u128>) {
arr.pop_front();
}
fn main() {
let mut new_arr: Array<u128> = array![1, 2, 3, 4, 5, 6, 7, 8];
let snapshot = @new_arr; // using `@` to create a snapshot of a variable
let len = get_len(snapshot); // pass the snapshot as argument, retaining ownership
foo(new_arr); // `new_arr` is still valid up until here and no further
}
একটি স্ন্যাপশটকে আবার সাধারণ ভ্যারিয়েবলে রূপান্তর করতে আপনি ডিস্ন্যাপ অপারেটর * ব্যবহার করতে পারেন, যা @ অপারেটরের ঠিক বিপরীত।
কেবল যে টাইপগুলো Copy ট্রেইট ইমপ্লিমেন্ট করে, সেগুলোই ডিস্ন্যাপ করা যায়।
fn square(n: @u32) -> u32 {
let n = *n; // we desnap the value
n * n
}
fn main() {
let num: u32 = 10;
let squared = square(@num); // we use `@` to create a snapshot
println!("{} squared = {}", num, squared);
}
রেফারেন্স দিয়ে আপনি ফাংশনে মিউটেবল মান পাঠাতে পারেন এবং সেগুলো স্বয়ংক্রিয়ভাবে ফেরতও পেতে পারেন, আর কলিং কনটেক্সটে ওনারশিপ অটুট থাকে।
এটি করা যায় ref মডিফায়ার দিয়ে, শর্ত হলো ভ্যারিয়েবলটি mut কিওয়ার্ড দিয়ে মিউটেবল হিসেবে ঘোষণা করা থাকতে হবে।
আগের Point উদাহরণটি আমরা Copy ট্রেইটের ওপর নির্ভর না করে বরং মিউটেবল রেফারেন্স ব্যবহার করে লিখতে পারি, আর সেটি তবুও কাজ করবে।
#[derive(Drop)]
struct Point {
x: u128,
y: u128,
}
fn foo(ref p: Point) {
// we can now update the passed values and the changes
// will be visible in the calling context
p.x += 1;
}
fn main() {
let mut p = Point { x: 5, y: 10 };
foo(ref p);
foo(ref p); // this now works even without the Copy trait
println!("p.x = {}", p.x); // p.x = 7
}
লার্নিং অনুশীলনী
