Rust Basics

Generički tipovi

Kreirajte strukturu gde jedna od njihovih vrednosti može biti bilo koji tip

struct Wrapper<T> {
value: T,
}

impl<T> Wrapper<T> {
pub fn new(value: T) -> Self {
Wrapper { value }
}
}

Wrapper::new(42).value
Wrapper::new("Foo").value, "Foo"

Option, Some & None

Tip Option znači da vrednost može biti tipa Some (postoji nešto) ili None:

pub enum Option<T> {
None,
Some(T),
}

Možete koristiti funkcije poput is_some() ili is_none() da proverite vrednost Option-a.

Makroi

Makroi su moćniji od funkcija jer se proširuju da bi proizveli više koda od koda koji ste ručno napisali. Na primer, potpis funkcije mora da deklariše broj i tip parametara koje funkcija ima. Makroi, s druge strane, mogu da prime promenljiv broj parametara: možemo pozvati println!("hello") sa jednim argumentom ili println!("hello {}", name) sa dva argumenta. Takođe, makroi se proširuju pre nego što kompajler tumači značenje koda, pa makro može, na primer, da implementira trait na datom tipu. Funkcija ne može, jer se poziva u vreme izvršavanja, a trait treba da bude implementiran u vreme kompilacije.

macro_rules! my_macro {
() => {
println!("Check out my macro!");
};
($val:expr) => {
println!("Look at this other macro: {}", $val);
}
}
fn main() {
my_macro!();
my_macro!(7777);
}

// Export a macro from a module
mod macros {
#[macro_export]
macro_rules! my_macro {
() => {
println!("Check out my macro!");
};
}
}

Iterirajte

Iteracija je proces ponavljanja određenog bloka koda više puta. U programiranju, iteracija se koristi za izvršavanje istog koda više puta, obično na različitim ulaznim podacima. To omogućava efikasno rukovanje velikim skupovima podataka ili izvršavanje istih operacija na različitim elementima.

U Rustu, iteracija se može postići korišćenjem petlji. Postoje dve osnovne vrste petlji u Rustu: for petlja i while petlja.

for petlja

for petlja se koristi kada želite da iterirate kroz kolekciju elemenata. Može se koristiti sa različitim tipovima kolekcija, kao što su vektori, nizovi ili opsezi.

let numbers = vec![1, 2, 3, 4, 5];

for number in numbers {
    println!("Broj: {}", number);
}

while petlja

while petlja se koristi kada želite da iterirate kroz blok koda dok je određeni uslov ispunjen. Uslov se proverava pre svake iteracije petlje.

let mut count = 0;

while count < 5 {
    println!("Brojač: {}", count);
    count += 1;
}

loop petlja

loop petlja se koristi kada želite da iterirate kroz blok koda beskonačno mnogo puta, ili dok se ne ispuni određeni uslov za prekid petlje.

let mut count = 0;

loop {
    println!("Brojač: {}", count);
    count += 1;

    if count == 5 {
        break;
    }
}

Korišćenje odgovarajuće petlje zavisi od specifičnih zahteva vašeg koda.

// Iterate through a vector
let my_fav_fruits = vec!["banana", "raspberry"];
let mut my_iterable_fav_fruits = my_fav_fruits.iter();
assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
assert_eq!(my_iterable_fav_fruits.next(), None); // When it's over, it's none

// One line iteration with action
my_fav_fruits.iter().map(|x| capitalize_first(x)).collect()

// Hashmap iteration
for (key, hashvalue) in &*map {
for key in map.keys() {
for value in map.values() {

Rekurzivna kutija

A recursive box is a data structure in Rust that allows for the creation of self-referential types. It is commonly used when dealing with data structures that have a recursive nature, such as linked lists or trees.

To create a recursive box, you can use the Box type provided by Rust. The Box type is a smart pointer that provides heap allocation and ownership of the data it points to.

Here is an example of how to create a recursive box:

struct Node {
    value: i32,
    next: Option<Box<Node>>,
}

fn main() {
    let node1 = Node {
        value: 1,
        next: Some(Box::new(Node {
            value: 2,
            next: Some(Box::new(Node {
                value: 3,
                next: None,
            })),
        })),
    };
}

In this example, the Node struct contains a value field of type i32 and a next field of type Option<Box<Node>>. The next field is an Option type because it can either contain a Box pointing to the next Node, or None to indicate the end of the list.

By using Box, we can allocate memory on the heap for each Node and create a recursive structure. The Box type ensures that the memory is deallocated correctly when it goes out of scope.

Recursive boxes are a powerful tool in Rust for creating complex data structures that require self-referentiality. They provide a safe and efficient way to handle recursive data without causing memory leaks or undefined behavior.

enum List {
Cons(i32, List),
Nil,
}

let list = Cons(1, Cons(2, Cons(3, Nil)));

ako

The if statement is used to execute a block of code only if a certain condition is true. It has the following syntax:

if condition {
    // code to be executed if the condition is true
}

The condition is an expression that evaluates to either true or false. If the condition is true, the code block inside the if statement will be executed. If the condition is false, the code block will be skipped.

Here's an example:

let number = 5;

if number > 0 {
    println!("The number is positive");
}

In this example, the code inside the if statement will be executed because the condition number > 0 is true. The output will be The number is positive.

ako

Naredba ako se koristi da izvrši blok koda samo ako je određeni uslov tačan. Ima sledeću sintaksu:

ako uslov {
    // kod koji će se izvršiti ako je uslov tačan
}

Uslov je izraz koji se vrednuje kao tačno ili netačno. Ako je uslov tačan, blok koda unutar naredbe ako će se izvršiti. Ako je uslov netačan, blok koda će biti preskočen.

Evo primera:

let broj = 5;

ako broj > 0 {
    println!("Broj je pozitivan");
}

U ovom primeru, kod unutar naredbe ako će se izvršiti jer je uslov broj > 0 tačan. Ispis će biti Broj je pozitivan.

let n = 5;
if n < 0 {
print!("{} is negative", n);
} else if n > 0 {
print!("{} is positive", n);
} else {
print!("{} is zero", n);
}

poklapanje

match je konstrukcija jezika Rust koja omogućava upoređivanje vrednosti sa različitim oblicima i izvršavanje odgovarajućeg koda na osnovu rezultata upoređivanja. Ova konstrukcija je veoma korisna za obradu različitih slučajeva ili opcija.

Evo osnovnog sintaksnog obrasca match izraza:

match vrednost {
    vrednost1 => {
        // Izvršava se kod ako vrednost odgovara vrednosti1
    },
    vrednost2 => {
        // Izvršava se kod ako vrednost odgovara vrednosti2
    },
    _ => {
        // Izvršava se kod ako vrednost ne odgovara ni jednoj od prethodnih vrednosti
    }
}

U ovom primeru, vrednost se upoređuje sa vrednost1, vrednost2 i _. Ako vrednost odgovara vrednost1, izvršava se kod unutar bloka vrednost1. Ako vrednost odgovara vrednost2, izvršava se kod unutar bloka vrednost2. Ako vrednost ne odgovara ni jednoj od prethodnih vrednosti, izvršava se kod unutar bloka _.

Ova konstrukcija omogućava efikasno upravljanje različitim slučajevima i olakšava čitanje i pisanje čistog i jasnog koda.

match number {
// Match a single value
1 => println!("One!"),
// Match several values
2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
// TODO ^ Try adding 13 to the list of prime values
// Match an inclusive range
13..=19 => println!("A teen"),
// Handle the rest of cases
_ => println!("Ain't special"),
}

let boolean = true;
// Match is an expression too
let binary = match boolean {
// The arms of a match must cover all the possible values
false => 0,
true => 1,
// TODO ^ Try commenting out one of these arms
};

petlja (beskonačna)

Kada želite da izvršite određeni blok koda beskonačan broj puta, možete koristiti petlju. Petlja se sastoji od uslova koji se proverava na početku svake iteracije. Ako je uslov ispunjen, blok koda se izvršava, a zatim se petlja ponavlja. U suprotnom, petlja se prekida i izvršavanje se nastavlja sa sledećim delom koda.

Da biste napravili beskonačnu petlju u Rustu, možete koristiti ključnu reč loop. Ova petlja će se izvršavati sve dok se ne prekine ručno ili dok se ne naiđe na break izjavu unutar petlje.

loop {
    // Blok koda koji se izvršava beskonačno
    // ...
}

Ova petlja je korisna kada želite da izvršite određene zadatke koji zahtevaju neprekidno izvršavanje, kao što je čitanje podataka sa senzora ili obrada zahteva u serverskoj aplikaciji.

loop {
count += 1;
if count == 3 {
println!("three");
continue;
}
println!("{}", count);
if count == 5 {
println!("OK, that's enough");
break;
}
}

dok

while petlja se koristi za ponavljanje određenog bloka koda sve dok je određeni uslov ispunjen.

while uslov {
    // Izvršavanje koda
}

Ovde je uslov izraz koji se evaluira kao true ili false. Ako je uslov true, blok koda unutar while petlje će se izvršavati. Kada se uslov evaluira kao false, izvršavanje petlje se zaustavlja i program nastavlja sa izvršavanjem koda nakon petlje.

Na primer:

let mut brojac = 0;

while brojac < 5 {
    println!("Vrednost brojaca je: {}", brojac);
    brojac += 1;
}

Ovde će se blok koda unutar while petlje izvršiti pet puta, jer će se brojac povećavati za jedan u svakoj iteraciji.

let mut n = 1;
while n < 101 {
if n % 15 == 0 {
println!("fizzbuzz");
} else if n % 5 == 0 {
println!("buzz");
} else {
println!("{}", n);
}
n += 1;
}

za

for n in 1..101 {
if n % 15 == 0 {
println!("fizzbuzz");
} else {
println!("{}", n);
}
}

// Use "..=" to make inclusive both ends
for n in 1..=100 {
if n % 15 == 0 {
println!("fizzbuzz");
} else if n % 3 == 0 {
println!("fizz");
} else if n % 5 == 0 {
println!("buzz");
} else {
println!("{}", n);
}
}

// ITERATIONS

let names = vec!["Bob", "Frank", "Ferris"];
//iter - Doesn't consume the collection
for name in names.iter() {
match name {
&"Ferris" => println!("There is a rustacean among us!"),
_ => println!("Hello {}", name),
}
}
//into_iter - COnsumes the collection
for name in names.into_iter() {
match name {
"Ferris" => println!("There is a rustacean among us!"),
_ => println!("Hello {}", name),
}
}
//iter_mut - This mutably borrows each element of the collection
for name in names.iter_mut() {
*name = match name {
&mut "Ferris" => "There is a rustacean among us!",
_ => "Hello",
}
}

ako je

if let je skraćenica za if let Some(x) = y. Ova konstrukcija se koristi za pattern matching i omogućava da se izvrši određeni kod samo ako je y jednak Some(x). Ako y nije jednak Some(x), kod se ne izvršava.

let option = Some(5);

if let Some(x) = option {
    println!("Vrednost je {}", x);
} else {
    println!("Nema vrednosti");
}

U ovom primeru, if let proverava da li je option jednak Some(x). Ako jeste, vrednost x se koristi u bloku if i ispisuje se "Vrednost je 5". Ako option nije jednak Some(x), izvršava se blok else i ispisuje se "Nema vrednosti".

let optional_word = Some(String::from("rustlings"));
if let word = optional_word {
println!("The word is: {}", word);
} else {
println!("The optional word doesn't contain anything");
}

while let

while let petlja je korisna kada želite da izvršavate određene radnje dok se određeni obrazac podudara sa vrednošću. Ova petlja se koristi u Rust programiranju.

while let Some(value) = iterator.next() {
    // Izvršavanje koda dok se obrazac podudara
}

Ova petlja će se izvršavati sve dok iterator.next() vraća Some(value). Kada iterator.next() vrati None, petlja se prekida.

Ova petlja je korisna kada radite sa iteratorima i želite da izvršavate određene radnje za svaku vrednost koju iterator vraća.

let mut optional = Some(0);
// This reads: "while `let` destructures `optional` into
// `Some(i)`, evaluate the block (`{}`). Else `break`.
while let Some(i) = optional {
if i > 9 {
println!("Greater than 9, quit!");
optional = None;
} else {
println!("`i` is `{:?}`. Try again.", i);
optional = Some(i + 1);
}
// ^ Less rightward drift and doesn't require
// explicitly handling the failing case.
}

Traitovi

Kreiranje nove metode za tip

trait AppendBar {
fn append_bar(self) -> Self;
}

impl AppendBar for String {
fn append_bar(self) -> Self{
format!("{}Bar", self)
}
}

let s = String::from("Foo");
let s = s.append_bar();
println!("s: {}", s);

Testovi

Testovi su ključni deo procesa razvoja softvera. Oni se koriste za proveru ispravnosti funkcionalnosti i otkrivanje grešaka u kodu. Testovi se mogu pisati na različite načine, kao što su jedinični testovi, integracioni testovi i sistemski testovi.

Jedinični testovi se fokusiraju na proveru ispravnosti pojedinačnih delova koda, kao što su funkcije ili metode. Oni se izvršavaju izolovano, bez zavisnosti od drugih delova sistema. Integracioni testovi se koriste za proveru ispravnosti interakcije između različitih delova sistema. Oni se izvršavaju na nivou modula ili komponenti. Sistemski testovi se koriste za proveru ispravnosti celokupnog sistema, uključujući sve njegove delove i interakcije.

Testovi se mogu pisati ručno ili automatski. Ručno pisanje testova može biti vremenski zahtevno i podložno greškama. Automatsko pisanje testova koristi alate i biblioteke za generisanje i izvršavanje testova. Automatski testovi su efikasniji i pouzdaniji, jer se mogu lako ponavljati i ažurirati.

Prilikom pisanja testova, važno je definisati očekivane rezultate i uslove za prolazak testa. Ovo omogućava jasnoću i objektivnost u oceni ispravnosti koda. Takođe je važno pokriti različite scenarije i granice kako bi se osigurala potpuna provera funkcionalnosti.

Testiranje je iterativan proces koji se obavlja tokom celog razvojnog ciklusa. Redovno testiranje pomaže u otkrivanju grešaka i poboljšanju kvaliteta softvera.

#[cfg(test)]
mod tests {
#[test]
fn you_can_assert() {
assert!(true);
assert_eq!(true, true);
assert_ne!(true, false);
}
}

Threadovanje

Arc

Arc može koristiti Clone da bi kreirao više referenci ka objektu kako bi ih prosledio threadovima. Kada poslednja referenca koja pokazuje na vrednost izađe iz opsega, promenljiva se briše.

use std::sync::Arc;
let apple = Arc::new("the same apple");
for _ in 0..10 {
let apple = Arc::clone(&apple);
thread::spawn(move || {
println!("{:?}", apple);
});
}

Niti

U ovom slučaju ćemo niti proslediti promenljivu koju će moći da izmeni.

fn main() {
let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
let status_shared = Arc::clone(&status);
thread::spawn(move || {
for _ in 0..10 {
thread::sleep(Duration::from_millis(250));
let mut status = status_shared.lock().unwrap();
status.jobs_completed += 1;
}
});
while status.lock().unwrap().jobs_completed < 10 {
println!("waiting... ");
thread::sleep(Duration::from_millis(500));
}
}