Хотя Rust очень и очень редко конкурирует в соревнованиях по коду (Java часто короче), играть в гольф все же может быть весело. Какие уловки можно сделать, чтобы код Rust был короче?

Пожалуйста, оставьте только один совет в каждом ответе.

Используйте замыкания вместо функций

Закрытие:

|n|n+1

короче функции:

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

Замыкания длиннее, чем один оператор, нуждаются в фигурных скобках, но все же намного короче, чем функция.

Избегайте .iter (). Enumerate ()

Допустим, у вас есть некоторый x, который реализует IntoIterator Trait, и вам нужно вызвать функцию f, которая берет индекс элемента и ссылку на него. Стандартный способ сделать это

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

вместо этого вы можете сделать

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

и спасите себя не только от необычайно длинного перечисления, но и от звонка в iter!

Если вам нужно много изменяемых переменных, это может привести к потере большого количества пространства, объявляя их и инициализируя их, так как для каждой требуется ключевое слово mut, и вы не можете сделать что-либо вроде a = b = c = 0. Решение тогда состоит в том, чтобы объявить изменяемый массив

let mut a=[0;5];

Каждый раз, когда вы их используете, вы тратите 3 дополнительных байта по сравнению с обычной переменной:

a[0]+=1;

но часто это может стоить того.

Использование кортежей для одного и того же трюка часто является еще лучшим вариантом:

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

Это имеет преимущество сохранения байта при каждом использовании по сравнению с массивом:

t.0=2

Это также позволяет им быть разных типов. С другой стороны, для инициализации требуется больше символов.

Преобразование &strвString

Никогда не делай так:

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

Это всегда короче:

s.repeat(1)    // 11 bytes

If sявляется строковым литералом:

format!(s)     // 10 bytes

Например: используйте format!("")вместо того, String::new()чтобы сохранить 2 байта.

Если вывод типа работает:

s.into()       // 8 bytes

При использовании строкового форматирования, например, с print!(), можно использовать как нумерованные, так и ненумерованные средства форматирования, чтобы сохранить один байт на элемент для форматирования:

Лучше всего показать на примере:

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

Какие выводы:

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

Таким образом, ненумерованные средства форматирования будут назначаться элементам по порядку, что позволяет пропустить индекс по ним. Обратите внимание, что вы можете использовать только один ненумерованный форматер для каждого элемента для форматирования, после этого он будет использован.

Чтение строк

После рассмотрения различных вещей, я думаю, что это, как правило, самый короткий способ получить строку. Строка имеет новую строку, ее можно удалить с помощью trimming ( .trim()) или, если это невозможно сделать с помощью нарезки.

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

Для нескольких строк linesможно использовать итератор, тогда итеративная строка не заканчивается новой строкой. Для импорта необходим глобальный импорт BufRead, необходимый для того, linesчтобы он был доступен для StdinLock<'_>типа.

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

Пропуск конечных точек с запятой

В возвращаемых функциях (), где последнее выражение также имеет тип (), вам не нужен трейлинг ;:

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

При работе со строками с символами новой строки в них вы сохраняете один байт, если в исходном коде вы используете разрыв строки в прямом выражении, а \nв строке - символ «a» .

println!("Hello
World!");

на 1 байт меньше чем:

println!("Hello\nWorld!);

При использовании целых чисел с плавающей точкой вы можете пропустить трейлинг, .0чтобы сохранить один байт.

let a=1.

на 1 байт меньше чем:

let a=1.0