01. Здравей, Rust

6 октомври 2017

Hello, world!

Защото винаги оттам се почва:

fn main() {
    println!("Hello, world!");
}

$ rustc hello.rs
$ ./hello
Hello, world!

Няма ли и по-лесен начин?

(има, разбира се)

$ cargo new hello --bin
$ cargo run
Hello, world!

Cargo

Package manager
Task runner
Подобно на mix в elixir, bundler в ruby, npm в node.js

Rustc

Удобно за временни файлове, бързи експерименти
Ненужно за повечето цели

Cargo

(demo)

Инсталация

https://fmi.rust-lang.bg/topics/1
Rustup (https://rustup.rs/)
$ rustup install stable
$ rustup doc

The Rust Book

https://doc.rust-lang.org/book/second-edition/

Rust playpen

https://play.rust-lang.org/

Основни типове

Числа

Length	Rust		C/C++
Length	Signed	Unsigned	Signed	Unsigned
8-bit	`i8`	`u8`	`char`	`unsigned char`
16-bit	`i16`	`u16`	`short`	`unsigned short`
32-bit	`i32`	`u32`	`int`	`unsigned int`
64-bit	`i64`	`u64`	`long long`	`unsigned long long`
arch	`isize`	`usize`	`long`	`unsigned long` / `size_t`

Типа u8 и типа char са напълно различни!

Основни типове

Числа (литерали)

Цяло число: 42
Специфичен тип: 42u32
Големи числа: 133_587
42_u32
1_0_0_0
1_____________________________________________________4

Основни типове

Числа (в различни бройни системи)

Hex: 0xDEADBEEF
Octal: 0o77
Binary: 0b1010011010

Основни типове

Числа (с плаваща запетая)

Length	Rust	C/C++
32-bit	`f32`	`float`
64-bit	`f64`	`double`

3.14 // f64
3.14_f32 // f32

Основни типове

bool

true
false
Големина 1 байт

Оператори &&, ||, &, |, ^, !
&& и || са мързеливи

Основни типове

unit

Rust	C/C++
`()`	`void`

Променливи

let pi: f64 = 3.14;
let pi      = 3.14;
let pi: f32 = 3.14;
let pi      = 3.14_f32;

Не може да се декларират множество променливи с едно let твърдение

let x = 5, y = 3;   // грешка

No emoji

fn main() {
    let 😀 = 123;
    println!("{:?}", 😀);
}

error: unknown start of token: \u{1f600}
--> src/main.rs:2:7
  |
2 |   let 😀 = 123;
  |       ^

error: Could not compile `playground`.

No emoji

Променливи

shadowing

let x = 10;
let x = x + 10;
let x = x * 3;

// the rest of the code

Променливи

shadowing

let x1 = 10;
let x2 = x1 + 10;
let x3 = x2 * 3;

// the rest of the code

Променливи

shadowing

let x = 10;
{
    let x = x + 10;
    {
       let x = x * 3;

       // the rest of the code
    }
}

Променливи

mutability

let x = 5;
x += 1;     // грешка

let mut x = 5;
x += 1;

immutable по подразбиране
ключова дума mut

Коментари

Едноредов коментар

// So we’re doing something complicated here, long enough that we need
// multiple lines of comments to do it! Whew! Hopefully, this comment will
// explain what’s going on.

Rust поддържа и блокови коментари /* ... */, но се предпочита използването на //

/*
  So we’re doing something complicated here, long enough that we need
  multiple lines of comments to do it! Whew! Hopefully, this comment will
  explain what’s going on.
*/

Конвертиране между типове

(type casting)

Ключовата дума as.

let one = true as u8;
let two_hundred = -56i8 as u8;
let three = 3.14 as u32;

Конвертиране от по-голям тип към по-малък може да доведе до загуба на данни

let x = 0b11111111_00000001_u16;
let y = x as u8;

println!("{}", y); // ??

Операции с числа

аритметика

let sum = 5 + 10;             // събиране
let difference = 95.5 - 4.3;  // изваждане
let product = 4 * 30;         // умножение
let quotient = 56.7 / 32.2;   // делене
let remainder = 43 % 5;       // остатък

Не може да прилагаме аритметичните операции върху числа от различни типове

let x = 4_u32 - 1_u8;         // грешка
let y = 1.2_f64 / 0.8_f32;    // грешка

Aритметични операции хвърлят грешка при препълванe (integer overflow / underflow)

let x = 255_u8;
let y = x + 1;                // 💥

Операции с числа

акумулативни операции

sum += 100;
difference -= 4.0;
product *= 1;
quotient /= 1.2;
remainder %= 2;

Няма оператори ++ и --

x += 1;
x -= 1;

Операции с числа

сравнения

2   >   1
x   <   95
3   >=  3
-10 <=  1
a   ==  a
5   !=  1000

Всички оператори за сравнение връщат резултат от тип bool.

Операции с числа

побитови операции

0b0010   &   0b0001
x        |     0x5F
0b0011   ^   0b1001
0b0001   <<       3
0b1000   >>       2
!x

Операторът за побитово отрицание е !

Control flow

if-клаузи

if bool_expression {
    // твърдения или изрази
} else if another_bool_expression {
    // твърдения или изрази
} else {
    // твърдения или изрази
}

Control flow

if-клаузи

if 2 > 1 {
    // твърдения или изрази
} else if 5 != 2 {
    // твърдения или изрази
} else {
    // твърдения или изрази
}

Control flow

цикли

while bool_expression {
    // твърдения или изрази
}

loop {
    // твърдения или изрази
}

loop e същото като while true, но по-четимо
for in работи с итератори

Control flow

Именувани цикли

'outer: loop {
    'inner: loop {
        break 'outer;
    }
    println!("John Cena");
}

'outer и 'inner се наричат етикети (labels)

Функции

fn main() {
    println!("Hello, world!");
    another_function();
}

fn another_function() {
    println!("Another function.");
}

Функции

fn name(param1: Type1, param2: Type2) -> ResultType {
    // тяло
}

fn add(a: u32, b: u32) -> u32 {
    // note no semicolon
    a + b
}

Задаването на типове на параметрите и резултата е задължително (няма type inference)
Върнатана стойност е стойността на последния израз в тялото на функцията
Ако искаме да излезем от функцията преди последния ред, може да използваме return
Използване на return на последния ред от тялото на функция се счита за лоша практика

Statements & Expressions

Твърдение (statement)

let x = (let y = 10);   // грешка

няма стойност
let x = 10;
return 25;

Statements & Expressions

Израз (expression)

операция която връща резултат
1
(2 + 3) * 4
add(5, 6)
може да се присвои на променлива чрез let

Statements & Expressions

if-else конструкцията е израз (expression)

let x = if true {
    5
} else {
    3
};

Rust няма тернарен оператор по тази причина

let x = if true { 5 } else { 3 };

Statements & Expressions

let x = loop {
    break 5;
};

loop е израз

Macros

генериране на код
различава се от функциите по ! след името
println!
print!

println! macro

let x = 5;
let y = 10;
println!("x = {} and y = {}", x, y);

Принтиране на конзолата
{} placeholders

Въпроси

http://fmi.rust-lang.bg/