تسمح لغة برمجة Rust ، التي بدأت كمشروع هواية وتدعمها لاحقًا شركة Mozilla Corporation ، للمبرمجين العاديين بكتابة أنظمة آمنة وسريعة في نفس الوقت: من الآلات الحاسبة إلى الخوادم المحملة بشكل كبير.

لقد نجحت هذه اللغة بالفعل في الحصول على صور نمطية لفترة قصيرة نسبيًا ، سأحاول دحض أربعة منها. يمكنني تخطي بعض النقاط ، والمناقشات في التعليقات مرحب بها.

1. الصدأ هي لغة برمجة معقدة
2. الصدأ هو قاتل C / C ++ آخر
3. أنقاض غير آمنة جميع الضمانات المقدمة من الصدأ
4. لن يتفوق الصدأ على C / C ++ بسرعة

1. الصدأ - لغة برمجة معقدة

يتم تحديد مدى تعقيد لغة البرمجة من خلال وجود عدد كبير من بنيات بناء الجملة التي لا تتوافق مع بعضها البعض. مثال رائع هو C ++ و C # ، لأنه بالنسبة للغالبية العظمى من المبرمجين ، فإن C ++ هي اللغة الأكثر تعقيدًا التي لا توجد بها C # ، على الرغم من العدد الكبير من عناصر بناء الجملة. الصدأ هو موحد جدا ل تم تصميمه في الأصل مع مراعاة أخطاء الماضي ، ويتم تقديم جميع الابتكارات حصرا لاتفاق مع تلك القائمة.

هذه الصورة النمطية لها جذورها في مفهوم عمر الروابط ، والذي يسمح لنا بوصف ضمانات صحة الروابط المستخدمة على مستوى دلالات اللغة. بناء الجملة مدى الحياة تبدو غريبة في البداية:

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