Mentre ruggine è molto, molto raramente competitivo nelle competizioni di golf di codice (Java è spesso più breve), può comunque essere divertente giocare a golf. Quali sono alcuni trucchi per accorciare il codice di Rust?

Si prega di inviare un solo suggerimento in ciascuna risposta

Usa le chiusure invece delle funzioni

Una chiusura:

|n|n+1

è più breve di una funzione:

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

Le chiusure più lunghe di un'istruzione richiedono parentesi graffe ma sono ancora molto più brevi di una funzione.

Evita .iter (). Enumerate ()

Supponiamo che tu abbia qualche x che implementa il tratto IntoIterator e che devi chiamare una funzione f che accetta l'indice di un elemento e un riferimento ad esso. Il modo standard per farlo è

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

invece puoi farlo

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

e salva te stesso non solo l'enorme elenco insolitamente lungo ma anche la chiamata a iter!

Se hai bisogno di molte variabili mutabili, puoi sprecare molto spazio dichiarandole e inizializzandole, poiché ognuna richiede la parola chiave mut e non puoi fare nulla come a = b = c = 0. Una soluzione quindi è dichiarare un array mutabile

let mut a=[0;5];

Spendi 3 byte extra ogni volta che li usi rispetto a una normale variabile:

a[0]+=1;

ma spesso può comunque valerne la pena.

L'uso delle tuple per lo stesso trucco è spesso un'opzione ancora migliore:

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

Ciò ha il vantaggio di salvare un byte su ogni utilizzo rispetto all'array:

t.0=2

Inoltre permette loro di essere di diversi tipi. L'aspetto negativo è che l'inizializzazione richiede più caratteri.

Conversione &strinString

Non fare mai questi:

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

Questo è sempre più breve:

s.repeat(1)    // 11 bytes

Se sè una stringa letterale:

format!(s)     // 10 bytes

Ad esempio: utilizzare format!("")invece diString::new() per salvare 2 byte.

Se l'inferenza del tipo funziona:

s.into()       // 8 bytes

Quando si utilizza la formattazione di stringa, ad esempio con print!(), è possibile utilizzare sia i formattatori numerati che quelli non numerati per salvare un byte per elemento nel formato:

Meglio mostrato con un esempio:

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

Quali uscite:

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

Quindi i formattatori non numerati verranno assegnati agli elementi in ordine, questo ti permetterà di saltare l'indice su di essi. Si noti che è possibile utilizzare solo un formattatore non numerato per elemento per formattare, dopodiché verrà utilizzato.

Linee di lettura

Dopo aver considerato varie cose, penso che sia generalmente il modo più breve per recuperare una linea. La linea ha una nuova riga, può essere rimossa tagliando ( .trim()) o se ciò non può essere fatto affettando.

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

Per più righe, è linespossibile utilizzare iteratore, quindi la riga iterata non termina in newline. Per importare è necessaria un'importazione glob BufRead, necessaria per linesessere disponibile per il StdinLock<'_>tipo.

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

Saltare i punti e virgola finali

Nelle funzioni di ritorno (), dove anche l'ultima espressione è di tipo (), non è necessario il trascinamento ;:

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

Quando si lavora con stringhe con newline in esse, si salva un byte se si utilizza un'interruzione di riga letterale nel codice sorgente rispetto a un carattere \nnella stringa.

println!("Hello
World!");

è 1 byte inferiore a:

println!("Hello\nWorld!);

Quando si utilizzano numeri in virgola mobile a numero intero, è possibile omettere il trailing .0per salvare un byte.

let a=1.

è 1 byte inferiore a:

let a=1.0