Apakah Rust begitu mengerikan seperti yang dilukis

Beberapa waktu yang lalu, saya mulai memahami perlunya mendiversifikasi pengalaman pemrograman saya secara eksklusif dalam C #. Setelah beberapa penelitian tentang berbagai opsi, seperti Haskell, Scala, Rust dan beberapa lainnya, pilihan jatuh pada yang terakhir. Seiring waktu, saya mulai memperhatikan bahwa Rust semakin banyak diiklankan hanya sebagai "bahasa sistem", yang diperlukan untuk kompiler rumit dan sistem super-load, dengan persyaratan khusus untuk keamanan dan multithreading, dan Go / Python / Java / ..., sementara saya menikmati dan cukup berhasil menggunakannya sebagai pengganti pekerja keras C # saya.

Dalam artikel ini, saya ingin berbicara tentang mengapa saya menganggap tren ini berbahaya secara umum, dan mengapa Rust adalah bahasa tujuan umum yang baik yang dapat digunakan untuk segala jenis proyek, dimulai dengan layanan Microsoft apa pun dan diakhiri dengan skrip rutin harian.

Pendahuluan

Mengapa, sebenarnya, belajar bahasa baru, semakin rumit? Tampak bagi saya bahwa jawaban untuk artikel "Menaklukkan biasa-biasa saja" paling dekat dengan kebenaran, yaitu:

Semua orang tahu bahwa menulis seluruh program secara manual dalam bahasa mesin adalah sebuah kesalahan. Tetapi mereka cenderung kurang memahami bahwa ada prinsip yang lebih umum: jika ada pilihan beberapa bahasa, adalah keliru untuk memprogram sesuatu selain yang paling kuat, jika pilihan tidak dipengaruhi oleh alasan lain.

Semakin kompleks bahasa, semakin kaya frasa yang dibuat dengan bantuannya, dan semakin baik ia mengekspresikan area subjek yang diperlukan. Karena konsep biasanya dipelajari hanya sekali, dan diterapkan berulang kali, itu jauh lebih menguntungkan dari sudut pandang menginvestasikan waktu Anda sendiri untuk mempelajari semua jenis kata-kata menakutkan seperti "transformator monadik" (dan juga, lebih disukai, artinya), kemudian untuk menyimpan kekuatan mental Anda dan membelanjakannya untuk sesuatu yang lebih menyenangkan. Dan karenanya sangat menyedihkan melihat tren beberapa perusahaan untuk membuat bahasa yang “disederhanakan” secara khusus. Akibatnya, kosakata bahasa-bahasa ini jauh lebih kecil, dan tidak sulit untuk mempelajarinya, tetapi kemudian membaca program “saya sendiri untuk membeli bawang” sangat sulit, belum lagi kemungkinan interpretasi yang ambigu.

Dasar-dasarnya

Bagaimana seorang pemula biasanya mengenal bahasa pemrograman? Dia google buku bahasa paling populer, menariknya, dan mulai membaca. Sebagai aturan, ini berisi HelloWorld, instruksi untuk menginstal kompiler, dan kemudian informasi dasar tentang bahasa dengan komplikasi bertahap. Dalam kasus rasta, ini adalah bajingan , dan contoh pertama adalah membaca nomor dari konsol dan menampilkannya di layar. Bagaimana kita melakukannya dalam C # yang sama? Yah, mungkin kira-kira seperti ini

var number = int.Parse(Console.ReadLine());
Console.WriteLine($"You guessed: {number}");

?

let mut guess = String::new();

io::stdin().read_line(&mut guess)
    .expect("Failed to read line");

let guess: u32 = guess.trim().parse()
    .expect("Please type a number!");

println!("You guessed: {}", guess);

, ( !), , .. " " "" .

:

let mut guess = String::new();
io::stdin().read_line(&mut guess)?;
let guess: u32 = guess.trim().parse()?;
println!("You guessed: {}", guess);

, , . , , . , , .

? - , , C# , , - .

.

fn search<F>(self, hash: u64, is_match: F, compare_hashes: bool)  
   -> RawEntryMut<'a, K, V, S>
  where for<'b> F: FnMut(&'b K) -> bool

, " ", " , ", " , GC ".

. , , . :

• Each elided lifetime in input position becomes a distinct lifetime parameter.
• If there is exactly one input lifetime position (elided or not), that lifetime is assigned to all elided output lifetimes.
• If there are multiple input lifetime positions, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes.
• Otherwise, it is an error to elide an output lifetime.

, , , , . . , -

struct Point(i32, i32);

impl Point {
    pub fn get_x(&self) -> &i32 {
        &self.0
    }

    pub fn get_y(&self) -> &i32 {
        &self.1
    }
}

, , .

• GC . C# IDisposable, , , GC " ", . : , ( try-with-resources Java), , foreach … , , . , , . , DI ,
• , 99% , .

, ( GC), ( ). : . , " ".

. , , :

. Rust 2018, . , . , .

pub struct Node {
    value: u64,
    next: Option<Box<Node>>,
    prev: Option<Box<Node>>,
}

, , .. Box<Node> , unique_ptr C++. , ,

:

pub struct Node {
    value: u64,
    next: Option<&Box<Node>>,
    prev: Option<&Box<Node>>,
}

( shared_ptr), . : - - . " , - ", dangling pointers . -, , , - " , , ".

, " ". , , , , ( Rc/Arc/Cell/RefCell), , .

: , . , , // . : GC , WeakReferences byte[] , , , . JS, , .

, " ", , . , , . , , . - , - . ownership'. , , , , .

. , , , .

,

error[E0382]: assign to part of moved value: `head`
  --> src\main.rs:23:5
   |
19 |         prev: Some(Box::new(head)),
   |                             ---- value moved here
...
23 |     head.next = Some(Box::new(next));
   |     ^^^^^^^^^ value partially assigned here after move
   |
   = note: move occurs because `head` has type `Node`, which does not implement the `Copy` trait

, , . , Copy , , - "", . , " ?".

, , compiler-driven development. , - , ", - . , . , ". , , :

fn foo<T: Copy>() {

}

fn bar<T>() {
    foo::<T>();
}

, :

error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied
 --> src\main.rs:6:5
  |
6 |     foo::<T>();
  |     ^^^^^^^^ the trait `std::marker::Copy` is not implemented for `T`
  |
  = help: consider adding a `where T: std::marker::Copy` bound
note: required by `foo`
 --> src\main.rs:1:1
  |
1 | fn foo<T: Copy>() {
  | ^^^^^^^^^^^^^^^^^

error: aborting due to previous error

where T: std::marker::Copy , , , !

, IDE , - , , / , - , IDE. - , , CI - - - . - IDE , , , . .

- , . , . , , , . .

, , . , , . . FFI ++ , . , . C# , " null", " KeyNotFoundException", " ", .. JS ( ) , .

, == . , , , . , , buffer overflow . , ( ).

— , , . . -, , , , , , , . , , , , C#/Java/Go/… , . , — . , , — .

. , , , , , , ", , !". , , . , , ( Java/C#/..., ), ( /++), , .

, , , , . , " ". , , - .