A linguagem de programação Rust , iniciada como um projeto de hobby e posteriormente suportada pela Mozilla Corporation, permite que programadores comuns escrevam sistemas seguros e rápidos ao mesmo tempo: de calculadoras a servidores muito carregados.

Por seu tempo relativamente curto de existência, essa linguagem já conseguiu adquirir estereótipos, quatro dos quais tentarei refutar abaixo. Posso pular alguns pontos, discussões nos comentários são bem-vindas.

1. Rust é uma linguagem de programação complexa
2. Rust é outro assassino de C / C ++
3. Inseguro arruina todas as garantias fornecidas pela Rust
4. A ferrugem nunca ultrapassará C / C ++ em velocidade

1. Rust - uma linguagem de programação complexa

A complexidade da linguagem de programação é determinada pela presença de um grande número de construções de sintaxe que são inconsistentes entre si. Um exemplo impressionante é C ++ e C #, porque para a grande maioria dos programadores, C ++ é a linguagem mais complicada que o C # não é, apesar do grande número de elementos de sintaxe. Ferrugem é bastante uniforme porque Foi originalmente concebido tendo em vista os erros do passado, e todas as inovações são introduzidas apenas sujeitas a acordo com as existentes.

Esse estereótipo tem suas raízes no conceito de vida útil dos links, o que nos permite descrever as garantias da validade dos links utilizados no nível da semântica da linguagem. A sintaxe ao longo da vida parece estranha a princípio:

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 , , ( ) . , . — .