Rust Trait

Rust provides many default Trait ready to use. There are:

Using generic type parameter with trait bounds could only able to define a homogeneous container which is checked during compile time. The following example shows how it looks like:

pub struct Screen<T: Draw> {
  pub components: Vec<T>,
}

impl<T> Screen<T> where T: Draw {
  ...
}

If a Screen object created, its field components will contain a vector of the type specified by the type parameter T and will be only able to store that particular type. This limited the flexibility of Rust to include different types that have the same trait.

One could use #202206221113 as in Box<dyn Trait> in order to have a container that could include various types that share the same trait. For example:

pub struct Screen {
  pub components: Vec<Box<dyn Draw>>,
}

pub struct Button {
  ...
}

impl Draw for Button {
  ...
}

pub struct SelectBox {
  ...
}

impl Draw for SelectBox {
  ...
}

By such, Screen will be able to hold a vector of struct that have the trait Draw. This means that the vector could hold both Button and SelectBox at the same time while still being able to be compiled. That being said, the checking is moved to runtime which obviously will introduce some overhead.

Links to this page

Rust Sync

Sync is a #202204061235 that allows the type to be referenced in a multithreading environment#. Rust primitive types has this trait implemented by default, and same as 202207172159, if the type is entirely composed of these types, then it will have this trait implicitly. Some types such as raw pointers, #202206221720 and Cell<T> related types (including #202206232210) doesn’t implement this trait.
Rust Smart Pointers

Rust standard library implements several smart pointers for better resource cleaned up as they have implemented the 202206221653# 202204061235#. If a reference go out of scope, depending on which kind of smart pointer that it is using, either it will be automatically destroyed or decrements the number of references that is pointing to the referred variable or object. Unlike other programming languages, such rule can be check in compile time if wanted.
Rust Send

Send is a #202204061235 that allows the ownership of implemented types to be transferred safely in a multithreading environment#. Almost all Rust types are implemented with Send trait, except #202206221720, and if the user’s custom type is composed of those types, then it will automatically have the Send trait. There is no method needed to be implemented in this trait.
Rust RefCell

However, it can’t be used in a multithreading environment# as it doesn’t implement the 202204061235# 202207172210#.
Rust Drop

Drop is a #202204061235 which could be used for automatic resource clean up# when the object or variable is out of scope. It is typically implemented in #202111301656. To implement the trait Drop, we need to implement the method drop for the structure:
Rust Deref

Deref is a #202204061235 that allows the dereferencing of a #data-structure or an enum. It is especially useful in #202111301656. All structures that implement the trait Deref must have the method deref implemented into them. This is shown as follow:
Rust Box

To have a type that implements a particular trait# rather than a specific type.

Box<T> is a kind of #202111301656 implemented by Rust standard library which is actually a single element Tuple with 202206221604# and Drop 202204061235#. It doesn’t have performance overhead. It stores data on the 202202062259# rather than on the 202112031157#. We can directly print the value (if it is of simple type) just like other primitive types without dereferencing it. Comparing to normal references, box is pointing to a copied value.
Reference Counting Pointer

Rc<T> can’t be used in a multithreading environment# as it doesn’t implement the 202204061235# 202207172159# and 202207172210#.
Mutex in Rust

As you can see that, we wrap around the Mutex into another type, Arc (imported from std::sync::Arc). It allows the data to be shared across multiple threads without violating the rule of Rust ownership, that is, it is atomic. You can treat it as 202206221720# with the 202207172159# and 202207172210# 202204061235#.

Further inspection into the code, we find out that Mutex offer interior mutability, and can be 202206221604# using the syntax *. It is essentially the same to the 202206232210#. Therefore, one advice is to treat Mutex as if it is a 202111301656# with 202207172210# 202204061235#.
C++ Concepts

It could be used to restrict the type which must matched the defined characteristics. Sort of like 202204061235. We could use it in a template like below:

#rust #oop