Embora o Rust seja muito, muito raramente competitivo em competições de golfe com código (o Java geralmente é mais curto), ainda pode ser divertido jogar golfe. Quais são alguns truques para tornar o código Rust mais curto?

Poste apenas uma dica em cada resposta.

Use fechamentos em vez de funções

Um fechamento:

|n|n+1

é mais curto que uma função:

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

Fechos com mais de uma instrução precisam de chaves, mas ainda são muito mais curtos que uma função.

Evite .iter (). Enumerate ()

Digamos que você tenha algum x que implementa a característica IntoIterator e você precisa chamar uma função f que leva o índice de um elemento e uma referência a ele. A maneira padrão de fazer isso é

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

em vez disso você pode fazer

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

e salve-se não apenas a enumeração incomumente longa, mas também a chamada para o iter!

Se você precisar de muitas variáveis ​​mutáveis, poderá gastar muito espaço declarando-as e inicializando-as, pois cada uma requer a palavra-chave mut e você não pode fazer nada como a = b = c = 0. Uma solução é declarar uma matriz mutável

let mut a=[0;5];

Você gasta 3 bytes extras cada vez que os usa em comparação com uma variável normal:

a[0]+=1;

mas muitas vezes ainda vale a pena.

Usar tuplas para o mesmo truque geralmente é uma opção ainda melhor:

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

Isso tem a vantagem de salvar um byte em cada uso versus a matriz:

t.0=2

Também permite que sejam de tipos diferentes. No lado negativo, requer mais caracteres para inicializar.

Convertendo &strparaString

Nunca faça o seguinte:

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

Isso é sempre mais curto:

s.repeat(1)    // 11 bytes

If sé uma string literal:

format!(s)     // 10 bytes

Por exemplo: use em format!("")vez de String::new()para salvar 2 bytes.

Se a inferência de tipo funcionar:

s.into()       // 8 bytes

Ao usar a formatação de string, por exemplo print!(), pode-se usar os formatadores numerados e não numerados para salvar um byte por item no formato:

Melhor mostrado com um exemplo:

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

Quais saídas:

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

Portanto, os formatadores não numerados serão atribuídos aos itens em ordem, permitindo que você pule o índice neles. Observe que você só pode usar um formatador não numerado por item para formatar; depois disso, ele será usado.

Linhas de leitura

Depois de considerar várias coisas, acho que geralmente é a maneira mais curta de recuperar uma linha. A linha tem uma nova linha, pode ser removida aparando ( .trim()) ou se isso não puder ser feito cortando.

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

Para várias linhas, o linesiterador pode ser usado, a linha iterada não termina em nova linha. É necessária uma importação global para importar BufRead, necessária para linesestar disponível para o StdinLock<'_>tipo.

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

Ignorando ponto e vírgula à direita

Nas funções retornadas (), onde a última expressão também é do tipo (), você não precisa do final ;:

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

Ao trabalhar com seqüências de caracteres com novas linhas, salve um byte se usar uma quebra de linha literal no código-fonte versus ter uma \nna sequência.

println!("Hello
World!");

é 1 byte menor que:

println!("Hello\nWorld!);

Ao usar números inteiros de ponto flutuante, você pode omitir o final .0para salvar um byte.

let a=1.

é 1 byte menor que:

let a=1.0