Si bien Rust es muy, muy raramente competitivo en competiciones de golf de código (Java es a menudo más corto), aún puede ser divertido jugar golf. ¿Cuáles son algunos trucos para acortar el código de Rust?

Publique solo un consejo en cada respuesta.

Use cierres en lugar de funciones

Un cierre:

|n|n+1

es más corto que una función:

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

Los cierres más largos que una declaración necesitan llaves pero aún son mucho más cortos que una función

Evite .iter (). Enumerate ()

Digamos que tiene alguna x que implementa el Rasgo IntoIterator y necesita llamar a una función f que tome el índice de un elemento y una referencia a él. La forma estándar de hacer esto es

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

en cambio puedes hacer

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

¡y ahórrese no solo la enumeración inusualmente larga sino también la llamada a iter!

Si necesita muchas variables mutables, puede desperdiciar mucho espacio declarándolas e inicializándolas, ya que cada una requiere la palabra clave mut y no puede hacer nada como a = b = c = 0. Una solución es declarar una matriz mutable

let mut a=[0;5];

Gastas 3 bytes adicionales cada vez que los usas frente a una variable normal:

a[0]+=1;

pero a menudo todavía puede valer la pena.

Usar tuplas para el mismo truco suele ser una opción aún mejor:

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

Esto tiene la ventaja de guardar un byte en cada uso frente a la matriz:

t.0=2

También les permite ser de diferentes tipos. En el lado negativo, requiere más caracteres para inicializar.

Convertir &straString

Nunca hagas esto:

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

Esto siempre es más corto:

s.repeat(1)    // 11 bytes

Si ses un literal de cadena:

format!(s)     // 10 bytes

Por ejemplo: usar en format!("")lugar deString::new() para guardar 2 bytes.

Si la inferencia de tipos funciona:

s.into()       // 8 bytes

Cuando se usa el formateo de cadenas, por ejemplo print!(), con , se pueden usar formateadores numerados y no numerados para guardar un byte por elemento para formatear:

Se muestra mejor con un ejemplo:

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

Qué salidas:

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

Por lo tanto, los formateadores no numerados se asignarán a los elementos en orden, esto le permite omitir el índice en ellos. Tenga en cuenta que solo puede usar un formateador sin numerar por elemento para formatear, después de eso se agotará.

Líneas de lectura

Después de considerar varias cosas, creo que generalmente es la forma más corta de recuperar una línea. La línea tiene una nueva línea, se puede eliminar recortando ( .trim()) o si eso no se puede hacer cortando.

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

Para varias líneas, linesse puede usar el iterador, la línea iterada no termina en nueva línea entonces. Se necesita una importación global para importar BufRead, necesaria para linesestar disponible para el StdinLock<'_>tipo.

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

Saltar puntos y comas

En las funciones que regresan (), donde la última expresión también es de tipo (), no necesita el seguimiento ;:

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

Al trabajar con cadenas con líneas nuevas en ellas, guarda un byte si usa un salto de línea literal en el código fuente en lugar de tener un \nen la cadena.

println!("Hello
World!");

es 1 byte menos que:

println!("Hello\nWorld!);

Al usar números de coma flotante de números enteros, puede omitir el final .0para guardar un byte.

let a=1.

es 1 byte menos que:

let a=1.0