Chociaż Rust bardzo, bardzo rzadko rywalizuje w zawodach golfa kodowego (Java jest często krótsza), nadal może być fajnie grać w golfa. Jakie są sztuczki skracania kodu Rust?

Proszę zamieścić tylko jedną wskazówkę w każdej odpowiedzi.

Używaj zamknięć zamiast funkcji

Zamknięcie:

|n|n+1

jest krótszy niż funkcja:

fn f(n:i32)->i32{n+1}

Zamknięcia dłuższe niż jedna instrukcja wymagają nawiasów klamrowych, ale są znacznie krótsze niż funkcja.

Unikaj .iter (). Enumerate ()

Załóżmy, że masz x, który implementuje cechę IntoIterator i musisz wywołać funkcję f, która pobiera indeks elementu i odniesienie do niego. Standardowy sposób to zrobić

x.iter().enumerate().map(f)

zamiast tego możesz zrobić

(0..).zip(x).map(f)

i uratuj nie tylko niezwykle długi wyliczenie, ale także wezwanie do iteracji!

Jeśli potrzebujesz wielu zmiennych, może to zmarnować dużo miejsca na ich zadeklarowanie i zainicjowanie, ponieważ każda wymaga słowa kluczowego mut i nie możesz zrobić czegoś takiego jak a = b = c = 0. Rozwiązaniem jest zatem zadeklarowanie zmiennej tablicy

let mut a=[0;5];

Wydajesz 3 dodatkowe bajty za każdym razem, gdy ich używasz, w porównaniu do normalnej zmiennej:

a[0]+=1;

ale często wciąż warto.

Używanie krotek do tej samej sztuczki jest często jeszcze lepszą opcją:

let mut t=(1,4,"this", 0.5, 'c');

Ma to tę zaletę, że oszczędza bajt przy każdym użyciu w porównaniu do tablicy:

t.0=2

Pozwala to również być różnego rodzaju. Z drugiej strony, wymaga więcej znaków do inicjalizacji.

Konwertowanie &strnaString

Nigdy nie rób tych:

s.to_string()  // 13 bytes
s.to_owned()   // 12 bytes

To zawsze jest krótsze:

s.repeat(1)    // 11 bytes

Jeśli sjest literałem ciągu:

format!(s)     // 10 bytes

Na przykład: użyj format!("")zamiast, String::new()aby zapisać 2 bajty.

Jeśli wnioskowanie typu działa:

s.into()       // 8 bytes

Korzystając z formatowania ciągów, na przykład z print!(), można użyć zarówno formatów numerowanych, jak i nienumerowanych, aby zapisać jeden bajt na element do sformatowania:

Najlepiej pokazano na przykładzie:

fn main(){
    print!("{}{}{}. Yes, {0}{}{2}. All you other{1}{2}s are just imitating.",
           "I'm",
           " Slim",
           " Shady",
           " the real");
}

Które wyjścia:

I'm Slim Shady. Yes, I'm the real Shady. All you other Slim Shadys are just imitating.

Zatem nienumerowane formaterery zostaną przypisane do elementów w kolejności, co pozwala pominąć indeks na nich. Pamiętaj, że możesz użyć tylko jednego nienumerowanego formatera na element do sformatowania, po czym zostanie on zużyty.

Czytanie wierszy

Po rozważeniu różnych rzeczy uważam, że jest to najkrótszy sposób na odzyskanie linii. Linia ma nową linię, można ją usunąć za pomocą przycinania ( .trim()) lub jeśli nie można tego zrobić przez przycięcie .

let y=&mut"".into();std::io::stdin().read_line(y);

W przypadku wielu linii linesmożna zastosować iterator, linia iterowana nie kończy się wtedy na nowej linii. Aby zaimportować, potrzebny jest import globalny BufRead, który musi linesbyć dostępny dla StdinLock<'_>typu.

use std::io::*;let y=stdin();y.lock().lines()

Pomijanie końcowych średników

W zwracanych funkcjach (), w których ostatnie wyrażenie jest również typu (), nie potrzebujesz końcowego ;:

fn main(){print!("Hello, world!")}

Pracując z ciągami znaków z nowymi liniami, zapisujesz jeden bajt, jeśli używasz dosłownego podziału wiersza w kodzie źródłowym, a nie \nciąg znaków.

println!("Hello
World!");

jest o 1 bajt mniejszy niż:

println!("Hello\nWorld!);

Używając liczb całkowitych zmiennoprzecinkowych, możesz pominąć znak końca, .0aby zapisać jeden bajt.

let a=1.

jest o 1 bajt mniejszy niż:

let a=1.0