[Question]
  [
While [Rust](https://www.rust-lang.org/) is very, very rarely competitive in code golfing competitions (Java is often shorter), it can still be fun to golf in. What are some tricks for making Rust code shorter?
Please post only one tip in each answer.
  
[Answer]
## Use closures instead of functions
A closure: 
```
|n|n+1
```
is shorter than a function:
```
fn f(n:i32)->i32{n+1}
```
---
Closures longer than one statement need braces but are still far shorter than a function.
[Answer]
# Converting `&str` to `String`
Never do these:
```
s.to_string()  // 13 bytes
s.to_owned()   // 12 bytes
```
This is always shorter:
```
s.repeat(1)    // 11 bytes
```
If `s` is a string literal:
```
format!(s)     // 10 bytes
```
For example: use `format!("")` instead of `String::new()` to save 2 bytes.
If type inference works:
```
s.into()       // 8 bytes
```
[Answer]
# Avoid .iter().enumerate()
Let's say you have some x that implements the IntoIterator Trait and you need to call a function f that takes the index of an element and a reference to it.
The standard way of doing this is
```
x.iter().enumerate().map(f)
```
instead you can do
```
(0..).zip(x).map(f)
```
and save yourself not only the unusually long enumerate but also the call to iter!
[Answer]
If you need many mutable variables, it can waste a lot of space declaring them and initializing them, since each requires the mut keyword and you can't do anything like a=b=c=0. A solution then is to declare a mutable array
```
let mut a=[0;5];
```
You spend 3 extra bytes each time you use them vs. a normal variable:
```
a[0]+=1;
```
but it can often still be worth it.
Using tuples for the same trick is often an even better option:
```
let mut t=(1,4,"this", 0.5, 'c');
```
This has the advantage of saving a byte on each use vs. the array:
```
t.0=2
```
It also lets them be of different types. On the downside, it requires more characters to initialize.
[Answer]
# Use `@` to define multiple variables to the same value
`@` is meant to define an alias for pattern matching (like destructuring an array but also getting the original array at the same time). But it works with plain variables too.
```
let a=2;let b=2; // 16 bytes
let(a,b)=(2,2);  // 15 bytes
let a@b=2;       // 10 bytes
```
It works in destructuring too:
```
let a=1;let b=1;let c=2;let d=2; // 32 bytes
let(a,b,c,d)=(1,1,2,2);          // 23 bytes
let(a@b,c@d)=(1,2);              // 19 bytes
```
[Answer]
When using string formatting for example with `print!()`, one can use both numbered and unnumbered formatters to save one byte per item to format:
Best shown with an example:
```
fn main() {
    print!(
        "{}{}{}. Yes, {0}{}{2}. All you other{1}{2}s are just imitating.",
        "I'm", " Slim", " Shady", " the real",
    );
}
```
Which outputs:
> 
> 
> ```
> I'm Slim Shady. Yes, I'm the real Shady. All you other Slim Shadys are just imitating.
> 
> ```
> 
> 
So the unnumbered formatters will get assigned to the items in order, this allows you to skip the index on them. Note that you can only use one unnumbered formatter per item to format, after that it will get used up.
[Answer]
# Skipping trailing semicolons
In functions returning `()`, where the last expression is also of type `()`, you don't need the trailing `;`:
```
fn main(){print!("Hello, world!")}
```
[Answer]
# Replace all `filter_map` with `flat_map`
It works because:
* `filter_map` takes a `FnMut(Self::Item) -> Option<B>`
* `flat_map` takes a `FnMut(Self::Item) -> impl IntoIterator`
* [`Option` implements `IntoIterator`](https://doc.rust-lang.org/std/option/enum.Option.html#impl-IntoIterator), which will return an
iterator with one item for `Some` and empty iterator for `None`
[Answer]
When working with strings with newlines in them, you save one byte if you use a literal line break in the source code vs having a `\n` in the string and/or using `println`.
```
print!("Hello
World!
");
```
is 2 bytes less than:
```
println!("Hello\nWorld!");
```
[Answer]
# Do-while loops
Rust does not have a C-style do-while loop:
```
do{do_work();}while(condition);
```
But blocks are also expressions in Rust, so you can write:
```
while{do_work();condition}{}
```
[Answer]
# Reading lines
After considering various things, I think that is generally the shortest way to retrieve a line. The line has a newline, it can be removed by trimming (`.trim()`) or if that cannot be done by slicing.
```
let y=&mut"".into();std::io::stdin().read_line(y);
```
For multiple lines, `lines` iterator can be used, the iterated line doesn't end in newline then. A glob import is needed to import `BufRead`, needed for `lines` to be available for `StdinLock<'_>` type.
```
use std::io::*;let y=stdin();y.lock().lines()
```
[Answer]
When using whole number floating point numbers, you can omit the trailing `.0` to save one byte.
```
let a=1.
```
is 1 byte less than:
```
let a=1.0
```
[Answer]
# Use `..=`
Replace all `..i+1` with `..=i` to save 1 byte, works on both array index `a[i..=i]` and range `(0..=n)`
[Answer]
# Use closure parameter to define variable instead of `let`
```
{let(a,b)=(A,B);X}
```
can be replaced by
```
(|a,b|X)(A,B)
```
to save 5 bytes if the type of `a` and `b` can be inferred, it usually works when they are integers or are passed to another function directly in `X`.
This works well on 2 or more variables, but for a single variable, this could still save 2 bytes if it allows you to get rid of the `{}`.
[Answer]
# Declare multiple variables using pattern matching
(Somewhat of an extension of <https://codegolf.stackexchange.com/a/99124/97519>)
Using multiple `let` statements:
```
let a=x;let b=y;
let a=x;let b=y;let c=z;
```
Using a tuple match saves 1 char for 2 variables and 3 more chars for ever variable after:
```
let(a,b)=(x,y);
let(a,b,c)=(x,y,z);
```
Similarly, you can use array patterns for initializing multiple mutable variables to the same value (this works with immutable variables too but is pretty useless):
```
let[mut a,mut b]=[x;2];
```
[Answer]
# Prefer todo! over panic!
[`todo!`](https://doc.rust-lang.org/std/macro.todo.html) is shorter than `panic!` by 1 byte, so prefer to use it if you need to panic and exit the program. It's also shorter than `print!` by a byte, so it can shorten your program if you can output to stderr instead of stdout.
```
todo!("optional message for stderr")
```
[Answer]
Use the `?` operator to unwrap infallible results. `?` is used for error propagation in conjunction with the result and option types, and [per this meta post](https://codegolf.meta.stackexchange.com/a/13262/97691) returning them with infallible results is a standard output method. For example, the following code summing the value of a string when interpreted in base a and b, with `?`:
```
|s,a,b|Ok(i32::from_str_radix(s,a)?+i32::from_str_radix(s,b)?)
```
and without:
```
|s,a,b|i32::from_str_radix(s,a).unwrap()+i32::from_str_radix(s,b).unwrap()
```
As you can see, with `?` it is much shorter, and it works with options as well, although often for smaller gains.
[Answer]
# `if let` can sometimes be shorter than `match`
Using `match`:
```
match a{M(v)=>expr,_=>other}
```
Using `if let` costs 2 bytes if there are only 2 branches and 1 is wildcard:
```
if let M(v)=a{expr}else{other}
```
More effective when your `match` needed `{}` anyways, like if the types don't match. For example:
```
match a{M(v)=>{expr;}_=>{other;}}
```
vs.:
```
if let M(v)=a{expr;}else{other;}
```
saves 1 byte.
[Answer]
# Loops are sometimes shorter than iterators
Even with the extra curly braces, in some cases it can be shorter to declare a mutable variable and use a loop instead of using `Iterator` methods.
For example, to do something with every third element of a slice and then return the last index:
```
|n:&[_]|{let mut i=0;while i<n.len(){println!("{}",n[i]);i+=3}i-3}
```
```
|n:&[_]|(0..=n.len()/3).map(|i|{println!("{}",n[i*3]);i*3}).last().unwrap()
```
[Answer]
# `(0..).scan` can be shorter than `std::iter::successors`
If you want to make endless sequences that are based on previous state:
```
std::iter::successors(Some(a),|x,_|Some(/*something*/))
```
This will be shorter by a character:
```
(0..).scan(a,|x,_|{let y=*x;*x=/*something*/;Some(y)})
```
If you don't mind dropping the first case, it can be even shorter:
```
(0..).scan(a,|x,_|{*x=/*something*/;Some(*x)})
```
[Answer]
# Get the nth element of a `String` or `&str` slice
In rust you can't directly index a string or slice. If you want to build a string from indexes of another string you would typically do this:
```
s.chars().nth(n).unwrap() // char
s.bytes().nth(n).unwrap() // u8
```
Shorter is this, but it will depend `s` so won't work if `s` is generated from a expression:
```
s.as_bytes()[n]as char // char, supports only single byte characters
s.as_bytes()[n] // u8
```
However, if you are ok with a `&str` (like if you want to collect into a `String` or concatenate with a existing `String`). This also supports only single byte characters.
```
&s[n..][..1] // &str
&s[n..=n] // &str, if `n` is a single variable or sufficiently short expression
```
If your expression is a literal you can use byte string instead to index it directly:
```
b"hello world"[n] // u8
b"hello world"[n]as char // char
```
[Answer]
# `scan` and `fold` on `Iterator`s can be used for stateful iteration
If your closure consists of variable declarations and iterating over something while keeping an internal state, you might be able to save some bytes by using `scan` or `fold` instead of a `for` loop:
```
|i:&str|{let(mut a,mut b,mut c)=(1,2,0);for x in i.chars(){/*AAA*/;/*BBB*/;c=/*CCC*/}c}
```
`scan` is good for handling many mutable variables, at the cost of some operations (such as assignment) requiring dereferencing with `*` and needing to collect the final value using a method like `last`:
```
|i:&str|i.chars().scan((1,2),|(a,b),x|{/*AAA*/;/*BBB*/;Some(/*CCC*/)}).last()
```
`fold` can also be used in a similar manner by passing values in the accumulator:
```
|i:&str|i.chars().fold((1,2,3),|(a,b,c),x|(/*AAA*/,/*BBB*/,/*CCC*/)).2
```
[Answer]
## Using slice patterns to get both an array and variables with the same value
It is a common trick to use array slicing to compactly assign many variables to the same value:
```
let[a,b,c]=[0;3]
// vs
let(a,b,c)=(0,0,0)
// or
let a=0;let b=0;let c=0;
```
I've never really seen this used on arrays, even though it also saves bytes there:
```
let[a,..@b]=[0;99]; // store "the rest" of the slice in b
// vs
let(a,b)=(0,[0;98]);
// or
let a=0;let b=[0;98];
```
Saves just one byte so may not be worth it if it increases the array size by one byte.
It works for mutable variables too:
```
let[mut v,mut u@..]=[0;99];
// vs
let(mut u,mut v)=(0,[0;98]);
```
]