Le langage de programmation Rust , commencé comme un projet de loisir et soutenu par la suite par Mozilla Corporation, permet aux programmeurs ordinaires d'écrire à la fois des systèmes sûrs et rapides: des calculatrices aux serveurs lourdement chargés.

Pour sa durée d'existence relativement courte, ce langage a déjà réussi à acquérir des stéréotypes, dont quatre j'essaierai de réfuter ci-dessous. Je peux sauter quelques points, les discussions dans les commentaires sont les bienvenues.

1. Rust est un langage de programmation complexe
2. La rouille est un autre tueur en C / C ++
3. Dangereux ruine toutes les garanties fournies par Rust
4. La rouille ne dépassera jamais C / C ++ en vitesse

1. Rust - un langage de programmation complexe

La complexité du langage de programmation est déterminée par la présence d'un grand nombre de constructions syntaxiques incompatibles entre elles. Un exemple frappant est C ++ et C #, car pour la grande majorité des programmeurs, C ++ est le langage le plus compliqué que C # n'est pas, malgré le grand nombre d'éléments de syntaxe. La rouille est assez uniforme car Il a été initialement conçu en tenant compte des erreurs du passé, et toutes les innovations sont introduites uniquement sous réserve d'un accord avec celles existantes.

Ce stéréotype trouve ses racines dans le concept de durée de vie des liens, qui permet de décrire les garanties de validité des liens utilisés au niveau de la sémantique du langage. La syntaxe de la durée de vie semble étrange au premier abord:

struct R<'a>(&'a i32);
unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> {
    std::mem::transmute::<R<'b>, R<'static>>(r)
}

unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>)
                                             -> &'b mut R<'c> {
    std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r)
}

— , . 'static , .

" "? , , . , main() something , .. produce_something() :

int *produce_something(void) {
    int something = 483;
    return &something;
}

int main(void) {
    int *something = produce_something();
    int dereferenced = *something; // Segmentation fault (core dumped)
}

. , , foo bar:

fn sum<'a, 'b: 'a>(foo: &'b i32, bar: &'a i32) -> i32 {
    return foo + bar;
}

, . — , , . .

Rust ( Rust). , : — , — .

. x Foo, y , x:

struct Foo {
    data: Vec<u8>,
}

fn main() {
    let x = Foo { data: Vec::new() }; //  (owning)
    let y = &x; //  (borrowing)
}

, , , . , Rust :

• ;
• .

2. Rust — " C/C++"

— " ". Rust — , , , C/C++. — SIMD -.

Vala, Zig, Golang . , , , C/C++. Vala Zig , Golang , .. (, ).

, C/C++ - , , Rust , - Java.

3. Unsafe , Rust

Unsafe, , — Rust, , "" Rust. Borrow-checker , - . :

• (FFI);
• ;
• ;
• ;
• .

, .. , . , .

//     UB :
fn safe_display() {
    unsafe {
        let x = 385;
        let x_ref: *const i32 = &x;
        println!("{}", *x_ref);
    }
}

: "Rust , ". , .. , Rust, . Rust .

: "Unsafe , Rust ". : " Java , , UB".

, UB, UB Rust. "", , "UB ", , . UB :

, (, ) , : « ».

4. Rust C/C++

. , , Rust, , C/C++. Rust GCC C:

, RapidJSON serde_json. serde_json DOM , RapidJSON, / serde_json RapidJSON (DOM) GCC, CLANG:

Rustls, OpenSSL ( 10% 20%-40% , 10%-20% 30%-70% ).

, Rust, rustc, C/C++ , CLANG, LLVM IR. , — .

rustc GCC/CLANG, , , . Rust C CLANG:

:
[https://godbolt.org/z/7b46MD]

pub fn compute(input: &mut [i64; 8]) {
    for i in 0..input.len() {
        input[i] = (input[i] + 3254) * 3;
    }
}

<T as core::convert::From<T>>::from:
        mov     rax, rdi
        ret

<T as core::convert::Into<U>>::into:
        mov     rax, rdi
        ret

<T as core::convert::TryFrom<U>>::try_from:
        mov     rax, rdi
        ret

<I as core::iter::traits::collect::IntoIterator>::into_iter:
        mov     rdx, rsi
        mov     rax, rdi
        ret

example::compute:
        xor     eax, eax
        jmp     .LBB4_1
.LBB4_3:
        mov     rcx, qword ptr [rdi + 8*rax]
        lea     rcx, [rcx + 2*rcx]
        add     rcx, 9762
        mov     qword ptr [rdi + 8*rax], rcx
        inc     rax
.LBB4_1:
        cmp     rax, 8
        jne     .LBB4_3
        ret

:
[https://godbolt.org/z/YOey3P]

#include <stdint.h>

void compute(int64_t *input) {
    for (int i = 0; i < 8; i++) {
        input[i] = (input[i] + 3254) * 3;
    }
}

compute:                                # @compute
        xor     eax, eax
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        cmp     rax, 8
        je      .LBB0_2
        mov     rcx, qword ptr [rdi + 8*rax]
        lea     rcx, [rcx + 2*rcx]
        add     rcx, 9762
        mov     qword ptr [rdi + 8*rax], rcx
        inc     rax
        jmp     .LBB0_1
.LBB0_2:
        ret

rustc , CLANG, — LLVM. rustc, Rust, .. ( CLANG).

Rust restrict -, . C/C++ , / restrict, .

Rust , , ( ) . , . — .