रस्ट प्रोग्रामिंग भाषा , एक शौक परियोजना के रूप में शुरू हुई और बाद में मोज़िला कॉर्पोरेशन द्वारा समर्थित, सामान्य प्रोग्रामर को एक ही समय में सुरक्षित और तेज़ दोनों सिस्टम लिखने की अनुमति देता है: कैलकुलेटर से भारी लोड वाले सर्वर तक।

अपने अपेक्षाकृत कम समय के अस्तित्व के लिए, यह भाषा पहले ही रूढ़ियों को हासिल करने में कामयाब रही है, जिनमें से चार मैं नीचे खंडन करने की कोशिश करूंगा। मैं कुछ बिंदुओं को छोड़ सकता हूं, टिप्पणियों में चर्चा का स्वागत है।

1. जंग एक जटिल प्रोग्रामिंग भाषा है
2. जंग एक और C / C ++ हत्यारा है
3. Rust द्वारा प्रदान की गई सभी गारंटियों को असुरक्षित बर्बाद कर देता है
4. जंग कभी भी गति में C / C ++ से आगे नहीं जाएगी

1. जंग - एक जटिल प्रोग्रामिंग भाषा

प्रोग्रामिंग भाषा की जटिलता बड़ी संख्या में सिंटैक्स निर्माण की उपस्थिति से निर्धारित होती है जो एक दूसरे के साथ असंगत हैं। एक हड़ताली उदाहरण सी ++ और सी # है, क्योंकि अधिकांश प्रोग्रामर के लिए, सी ++ सबसे जटिल भाषा है जो बड़ी संख्या में सिंटैक्स तत्वों के बावजूद सी # नहीं है। जंग बहुत सुंदर है क्योंकि यह मूल रूप से अतीत की गलतियों के लिए एक आंख के साथ डिजाइन किया गया था, और सभी नवाचारों को मौजूदा लोगों के साथ समझौते के अधीन रखा गया है।

इस स्टीरियोटाइप में लिंक के जीवनकाल की अवधारणा में अपनी जड़ें हैं, जो भाषा के शब्दार्थ के स्तर पर उपयोग किए गए लिंक की वैधता की गारंटी का वर्णन करने की अनुमति देता है। लाइफ-टाइम सिंटैक्स पहले अजीब लगता है:

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