+++
title = "Rust"
description = "Základy"
date = 2021-01-21
draft = false
slug = "rust-bases"

[taxonomies]
categories = ["programování"]
tags = ["rust"]
+++

Univerzální jazyk. Lze použít jako nízkoúrovňový i pro webový backend. Kompiluje se do nativní staticky linkované binárky. Klade důraz na bezpečnost, takže je těžší udělat memory leak, nebo data race condition ve vícevláknové aplikaci. Nemá garbage collector, memory management je řešen přes systém vlastnictví a zápujček.

```rust
fn main() {
    println!("ahoj");
}
```

## Memory management

- každá hodnota má proměnnou, která je vlastníkem hodnoty
- hodnota má pouze jednoho vlastníka
- se zánikem vlastníka, zaniká hodnota

```rust
{
    let a = String::from("pokus"); // proměnná a je vlastníkem stringu "pokus"
    let b = a; // teď je vlastníkem proměnná b, proměnnou a už nelze dál použít
} // string "pokus" je odstraněn z paměti
```

Hodnoty se do funkcí dají buď přesunout, nebo předat referencí. V Rustu se tomu říká zápujčka.

```rust
struct St {
    prop: String;
}

fn funkce(a: String, b: &str, c: &St) {
    ...
}

fn main() {
    let pok = String::from("pokus");
    let pok1 = "pokus1";
    let stru = St {
        prop: String::from("prop"),
    };
    funkce(pok, pok1, &stru);
    //pok je přesunuto, už nelze dál použít
    //pok1 je reference na řetězec, předává se referencí, lze dál používat. Při volání se  
    //před pok1 nepíše &, protože to je reference už od začátku.
    //stru je instance struktury St, funkce očekává referenci, takže při volání musíme  
    //napsat &stru
}
```

Platnost referencí hlídá borrow checker při kompilaci. Pokud je reference použitá za koncem platnosti, program nelze přeložit.

```rust
{
    let r;
    {
        let x = 5;
        r = &x; //nelze, protože platnost x končí s koncem bloku
    }
    println!("r: {}", r); //neplatná reference, nepůjde přeložit.
}
```

<a href="https://doc.rust-lang.org/book/" target="_blank">Rust book</a>