A ferrugem é tão terrível quanto é pintada

Há algum tempo, comecei a entender a necessidade de diversificar minha experiência de programação exclusivamente em C #. Após um estudo de várias opções, como Haskell, Scala, Rust e outras, a escolha recaiu sobre este último. Com o tempo, comecei a prestar atenção que cada vez mais o Rust é anunciado apenas como uma "linguagem do sistema", necessária para compiladores complicados e sistemas super-carregados, com requisitos especiais de segurança e multithreading, e Go / Python / Java / ..., enquanto eu desfrutava e o utilizava com êxito como um substituto para o meu cavalo de trabalho C #.

Neste artigo, eu queria falar sobre por que considero essa tendência prejudicial em geral e por que Rust é uma boa linguagem de uso geral que pode ser usada para qualquer tipo de projeto, começando com qualquer microsserviço e terminando com o script de rotina diária.

1. Introdução

Por que, de fato, aprender um novo idioma, ainda mais complicado? Parece-me que a resposta ao artigo "Conquistando a mediocridade" está mais próxima da verdade, a saber:

Todo mundo sabe que escrever o programa inteiro manualmente em linguagem de máquina é um erro. Mas eles são muito menos propensos a entender que existe um princípio mais geral: se houver uma escolha de várias línguas, é errado programar algo diferente do mais poderoso, se a escolha não for influenciada por outros motivos.

Quanto mais complexa a linguagem, mais ricas são as frases feitas com sua ajuda e melhor é a expressão da área de assunto exigida. Porque Geralmente, os conceitos são estudados apenas uma vez e aplicados repetidamente. É muito mais lucrativo, do ponto de vista de investir seu tempo, estudar todo tipo de palavras assustadoras como "transformadores monádicos" (e também, de preferência, o significado deles), para economizar sua força mental e gastá-los em algo mais agradável. E, portanto, é muito triste ver a tendência de algumas empresas de criar linguagens especialmente "simplificadas". Como resultado, o vocabulário dessas línguas é muito menor, e não é difícil aprendê-lo, mas ler os programas “meu próprio para comprar cebolas” é muito difícil, sem mencionar as possíveis interpretações ambíguas.

O básico

Como um iniciante geralmente conhece uma linguagem de programação? Ele pesquisa no Google o livro de idiomas mais popular, o pega e começa a ler. Como regra, ele contém o HelloWorld, instruções para instalar o compilador e, em seguida, informações básicas sobre o idioma com uma complicação gradual. No caso de rasta, isso é um bastardo , e o primeiro exemplo é ler um número no console e exibi-lo na tela. Como faríamos isso no mesmo c #? Bem, provavelmente algo como isto

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#/..., ), ( /++), , .

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