Comments-

// For single line comments let article = NewsArticle {

/* For headline: "News Article".to_string(),
multiline body: "This is the body of the
comments article".to_string(),
*/ };
Doc comment-
/// Generate library docs for the following let summary = summarize(&article);
item.
//! Generate library docs for the enclosing In rust type reference the data type.Every
item. value in rust has a type.

Formatted print- Debug-

formate!(“Hello formate macro”);
print!(“Printing without newline”);
println!(“Printing with newline”);
eprint!(“Printing with standard error”);
eprintln!(“Printing with standard error and
newline”);
Trait-
trait is a collection of methods that a type
can implement. It defines a set of behaviors
that a type can exhibit, and it allows you to
define generic code that works with any
type that implements the trait.
Exm-
trait Summary {
fn summarize(&self) -> String;
} println!("{:?}", p);
struct NewsArticle {
headline: String,
body: String,
} fmt::Formatter::debug_struct method. This
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}: {}", self.headline, self.body)
}
}
fn summarize(item: &impl Summary) ->
String {
item.summarize()
}
In Rust, the debug attribute allows you to
use the {:?} formatting specifier to print out a
value in a human-readable format for
debugging purposes. It can be applied to
structs, enums, and other types.
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
The #[derive(Debug)] attribute tells the Rust
compiler to automatically implement the
Debug trait for the Point struct. This allows
you to print out values of the Point type
using the {:?} formatting specifier.
let p = Point { x: 3, y: 4 };
You can also implement the Debug trait
manually for your own types by
implementing the fmt::Debug trait and the
allows you to customize the way your type
is printed when using the {:?} formatting
specifier.
Tupple- -You can also define methods on enums by
tuple is a fixed-size collection of values of using the impl keyword
different type impl Color {
let t = (1, "hello", 3.14); fn mix(&self, other: &Color) -> Color {
let (x, y, z) = t; match (self, other) {
println!("x = {}, y = {}, z = {}", x, y, z); (Color::Red, Color::Blue) =>
let x = t.0; Color::Purple,
let y = t.1; (Color::Blue, Color::Red) =>
let z = t.2; Color::Purple,
println!("x = {}, y = {}, z = {}", x, y, z); (Color::Red, Color::Green) =>
Color::Yellow,
Array-an array is a fixed-size collection of (Color::Green, Color::Red) =>
values of the same type Color::Yellow,
let a = [1, 2, 3, 4, 5]; (Color::Green, Color::Blue) =>
let a = [0; 10]; Color::Cyan,
let x = a[2]; (Color::Blue, Color::Green) =>
Color::Cyan,
Sturct-a struct (short for "structure") is a _ => *self,
compound data type that allows you to }
group together related values }
struct Point { }
x: i32,
y: i32, This defines a method called mix on the
} Color enum that mixes two colors together
let p = Point { x: 3, y: 4 }; and returns the resulting color. You can call
let x = p.x; this method like this:
let y = p.y;
println!("x = {}, y = {}", x, y); let purple = Color::Red.mix(&Color::Blue);

impl Point { Shadowing-In Rust, the term "shadowing"

fn distance_to_origin(&self) -> f64 { refers to the practice of using a new variable
(self.x.pow(2) + self.y.pow(2)).sqrt() with the same name as an existing variable,
} thereby "shadowing" the original variable
} let x = 5;
let distance = p.distance_to_origin(); let x = x + 1;
let x = x * 2;
println!("x = {}", x);
Enum-An enum (short for "enumeration") is
a type that represents a fixed set of value //The final value of x is 12.
enum Color {
Red, Type-
Green, Casting-casting refers to the process of
Blue, converting a value of one type to a value of
} another type.
let x: i32 = 5;
let y: f64 = x as f64;
Mutuality-In rust variable are mutable by
default.For making a variable to immutable
you have to be use “mut” keyword.
let x=5;
x=4; //Give you a compilation time error
cause here we are using by default mutable
variable
let mut x=5;
x=4; //No error will be provided
Casting/Converting-
you can use the as keyword to perform a
type conversion, also known as casting.
let x: i32 = 5;
let y: f64 = x as f64;
Literals-
In Rust, a literal is a value written directly in
the source code. There are several types of
literals in Rust, including integers,
floating-point numbers, characters, strings,
and boolean values.
let x = 42; // x has the value 42
let y = 0xff; // y has the value 255 (0xff is
hexadecimal notation)
let z = 0o77; // z has the value 63 (0o77 is
octal notation)
let w = 0b1111_0000; // w has the value 240
(0b1111_0000 is binary notation)
Inference-Type inference in Rust is a
feature that allows the Rust compiler to
automatically determine the type of a value
based on the context in which it is used.
let x=5;
Aliasing-In Rust, you can use the type
keyword to create an alias for an existing
type
Here's an example of how to use the type
keyword to create an alias for a tuple type:
type Point = (i32, i32);
let p: Point = (0, 0);
You can also use the type keyword to create
an alias for a function type:
type BinOp = fn(i32, i32) -> i32;
fn add(x: i32, y: i32) -> i32 {
x+y
}
fn subtract(x: i32, y: i32) -> i32 {
x-y
}
let add_op: BinOp = add;
let subtract_op: BinOp = subtract;
Conversion-
In Rust, the From and Into traits are used to
specify conversion between types. The
From trait allows you to convert a value of
one type into a value of another type, while
the Into trait allows you to convert a value of
one type into a value of another type and
take ownership of the value in the process.
From-
use std::convert::From;
#[derive(Debug)]
struct Num {
value: i32,
}
 To and from string-
impl From<i32> for Num { In Rust, you can use the ToString and
fn from(item: i32) -> Self { FromStr traits to convert values to and from
Num { value: item } strings. The ToString trait allows you to
} convert a value of a type to a String, while
} the FromStr trait allows you to convert a
String to a value of a type.
let num = Num::from(42);
println!("{:?}", num); // prints "Num { value: use std::string::ToString;
42 }"
#[derive(Debug)]
In this example, the Num struct has an impl struct Num {
block that implements the From<i32> trait value: i32,
for the Num type. This allows you to convert }
an i32 value into a Num value using the
‘From::from’ method. impl ToString for Num {
fn to_string(&self) -> String {
self.value.to_string()
Into- }
}
use std::convert::Into;
let num = Num { value: 42 };
#[derive(Debug)] let s = num.to_string();
struct Num { println!("{}", s); // prints "42"
value: i32,
}
use std::str::FromStr;
impl Into<i32> for Num {
fn into(self) -> i32 { #[derive(Debug)]
self.value struct Num {
} value: i32,
} }
//Fromstring
let num = Num { value: 42 }; impl FromStr for Num {
let x: i32 = num.into(); type Err = std::num::ParseIntError;
println!("{}", x); // prints "42"
fn from_str(s: &str) -> Result<Self,
In this example, the Num struct has an impl Self::Err> {
block that implements the Into<i32> trait for Ok(Num { value: s.parse()? })
the Num type. This allows you to convert a }
Num value into an i32 value using the }
Into::into method and take ownership of the
Num value in the process. let s = "42";
let num = Num::from_str(s).unwrap();
println!("{:?}", num); // prints "Num { value:
42 }" // Infinite loop
loop {
count += 1;
Expression-An expression is a piece of
code that returns a value. if count == 3 {
You can use the let keyword to bind the println!("three");
result of an expression to a variable.
let x = (5 + 2) * 3; // x is 21 // Skip the rest of this iteration
let y = let z = x + 1; // y is 22, z is 21 continue;
}
Flow control-
1.If-> println!("{}", count);

let x = 5; if count == 5 {
if x > 0 { println!("OK, that's enough");
println!("x is positive");
} else { // Exit this loop
println!("x is non-positive"); break;
} }
}
2.while-> }

let mut x = 0;

while x < 10 {
println!("x is {}", x); for loop-
x += 1;
} let fruits = ["apple", "banana", "orange"];
for fruit in fruits {
3.match-> println!("{}", fruit);
}
let x = 5;
match x {
0 => println!("x is zero"),
1...5 => println!("x is between 1 and 5"), Function-A function is a block of code that
_ => println!("x is something else"), performs a specific task and can be called
} by name.

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

fn main() { x+y
let mut count = 0u32; }

println!("Let's count until infinity!");

Closure-In Rust, a closure is a function-like self-The `self` keyword refers to the current
value that can capture variables from its module scope
surrounding environment. super-The `super` keyword refers to the
parent scope
let add = |x: i32, y: i32| -> i32 { x + y };
trait MyTrait {
Module- fn my_method(&self);
mod my_module { }
pub mod submodule {
pub fn function() { struct MyStruct;
// ...
} impl MyTrait for MyStruct {
} fn my_method(&self) {
} println!("In MyStruct implementation of
MyTrait");
use my_module::submodule; }
}
submodule::function();
trait MyChildTrait: MyTrait {
Use/as- fn my_child_method(&self) {
self.my_method();
mod my_module { println!("In MyChildTrait");
pub struct MyStruct { }
// ... }
}
impl MyChildTrait for MyStruct {
pub fn function1() { fn my_method(&self) {
// ... super::my_method(self);
} println!("In MyStruct implementation of
MyChildTrait");
pub fn function2() { }
// ... }
}
} Generics-Generics are a way to write code
that can work with multiple types, rather
use my_module::{MyStruct as than being tied to a specific type. This
MyRenamedStruct, function1 as allows you to write more flexible and
my_function, *}; reusable code, and helps you avoid
duplicating code for different types.
fn main() {
let s = MyRenamedStruct { /* ... */ }; fn max<T: PartialOrd>(x: T, y: T) -> T {
my_function(); if x > y {
function2(); x
} } else {
 y height: f64,
} }
}
Here, T is the type parameter and
PartialOrd is a trait constraint, which means
that T must implement the PartialOrd trait in
order to be used with this function. The
function takes two arguments x and y of
type T and returns a value of type T
//Generic with struct
struct Point<T> {
x: T,
y: T,
} This means that any Rectangle value now
Here, the Point struct has a type parameter
T that is used to specify the type of the x
and y fields. This allows you to create
instances of Point with any type that is valid
for the x and y fields.
Trait-In Rust, a trait is a way to specify a set
of behaviors that a type must implement.
Traits are similar to interfaces in other
languages.
Here's an example of a trait definition in
Rust:
trait Shape {
fn area(&self) -> f64;
fn perimeter(&self) -> f64;
} ● Clone, to create T from &T via a
This trait, Shape, defines two methods: area
and perimeter. Any type that implements the
Shape trait must provide an implementation
for these two methods.To implement a trait
for a type, you use the impl keyword, like
this:
struct Rectangle {
width: f64,
impl Shape for Rectangle {
fn area(&self) -> f64 {
self.width * self.height
}
fn perimeter(&self) -> f64 {
2.0 * (self.width + self.height)
}
}
Here, we define a struct Rectangle and then
implement the Shape trait for Rectangle.
has an area and a perimeter, and we can
call these methods on Rectangle values just
like any other method.
Trait bounds are a way to specify that a
generic type must implement a particular
trait. For example
fn print_area<T: Shape>(shape: T) {
println!("The area is {}", shape.area());
}
The following is a list of derivable traits:
● Comparison traits: Eq,
PartialEq, Ord, PartialOrd.
copy.
● Copy, to give a type 'copy
semantics' instead of 'move
semantics'.
● Hash, to compute a hash from &T.
● Default, to create an empty
instance of a data type.
● Debug, to format a value using the
{:?} formatter.