Updated if.md

sarojaba authored
revision 4827162cb8a9ced05c2f9c70dd18ecac13accd9d
if
# 25.5. 만약에 (Iif)

Rust's take on `if` is not particularly complex, 그러나 전통적인 시스템 언어보다 동적 타입 언어에서의 `if`와 비슷할 것입니다. 이에 대해 더 이야기해봅시다, to make sure you grasp the nuances.

`if`는 일반적인 개념인 *분기(branch)*의구체화된 형식입니다. 나무의 가지에서 이름을 따왔고, 선택에따라 다양한 경로가 취해질 수 있는 결정 포인트 역할을 합니다.

`if`의 경우, 하나의 결정에 두개의 경로가 따라옵니다.

```rust
let x = 5;

if x == 5 {
println!("x is five!");
}
```

만약 무언가 하기 위해 `x`의 값을 변경했다면, 이 라인은 출력되지 않을 것입니다. 더 자세히, 만약 `if` 다음에 오는 식이 `true`으로 평가된다면, 블록은 실행됩니다. `false`라면, 그렇지 못합니다.

`false`인 경우에 어떤일이 벌어지길 원한다면, `else`를 사용하세요.

```{rust}
let x = 5;

if x == 5 {
println!("x is five!");
} else {
println!("x is not five :(");
}
```

하나의 경우가 더 있다면, `else if`를 사용하세요.

```rust
let x = 5;

if x == 5 {
println!("x is five!");
} else if x == 6 {
println!("x is six!");
} else {
println!("x is not five or six :(");
}
```

이렇게 하는 것은 정말 표준적인 방식입니다. 하지만, 이렇게도 할 수 있습니다.

```{rust}
let x = 5;

let y = if x == 5 {
10
} else {
15
}; // y: i32
```

또는 이와 같이 작성할 수도 있습니다.

```{rust}
let x = 5;

let y = if x == 5 { 10 } else { 15 }; // y: i32
```

This reveals two interesting things about Rust: '표현식' 기반의 언어라는 점과, 세미콜론이 '중괄호와 세미콜론' 기반의 언어에서의 세미콜론과 다르다는 것입니다. 이 두 가지는 연관이 있습니다.

## 표현식 vs. 구문

Rust은 기본적으로 표현식 기반 언어입니다. 두 종류의 구문이 있고, 나머지는 모두 표현식입니다.

근데 무엇이 다른가요? 표현식은 값을 반환하지만, 구문은 반환값이 없습니다.
많은 언어에서, `if`는 구문이므로, `let x = if ...`는 말이 되지 않습니다. 하지만 Rust에서는, `if`는 표현식이고, 이는 값을 반환한다는 것을 의미합니다. We can then use this value to initialize the binding.

Speaking of which, bindings are a kind of the first of Rust's two statements.
The proper name is a *declaration statement*. So far, `let` is the only kind
of declaration statement we've seen. Let's talk about that some more.

Ruby와 같은 언어에서는, 변수 바인딩은 문장이 아닌, 표현식으로 작성될 수 있습니다.

```{ruby}
x = y = 5
```

그러나 Rust에서는, 바인딩이 _not_ 표현식이 _아닌_것을 알려주기 위해 `let`을 사용합니다. 다음은 컴파일시에 에러를 발생할 것입니다.

```{ignore}
let x = (let y = 5); // expected identifier, found keyword `let`
```

컴파일러는 telling us here that it was expecting to see the beginning of
an expression, and a `let` can only begin a statement, not an expression.

Note that assigning to an already-bound variable (e.g. `y = 5`) is still an
expression, although its value is not particularly useful. Unlike C, where an
assignment evaluates to the assigned value (e.g. `5` in the previous example),
in Rust the value of an assignment is the unit type `()` (which we'll cover later).

The second kind of statement in Rust is the *expression statement*. Its
purpose is to turn any expression into a statement. In practical terms, Rust's
grammar expects statements to follow other statements. This means that you use
semicolons to separate expressions from each other. This means that Rust
looks a lot like most other languages that require you to use semicolons
at the end of every line, and you will see semicolons at the end of almost
every line of Rust code you see.

What is this exception that makes us say "almost"? You saw it already, in this
code:

```{rust}
let x = 5;

let y: i32 = if x == 5 { 10 } else { 15 };
```

Note that I've added the type annotation to `y`, to specify explicitly that I
want `y` to be an integer.

This is not the same as this, which won't compile:

```{ignore}
let x = 5;

let y: i32 = if x == 5 { 10; } else { 15; };
```

Note the semicolons after the 10 and 15. Rust will give us the following error:

```text
error: mismatched types: expected `i32`, found `()` (expected i32, found ())
```

We expected an integer, but we got `()`. `()` is pronounced *unit*, and is a
special type in Rust's type system. In Rust, `()` is _not_ a valid value for a
variable of type `i32`. It's only a valid value for variables of the type `()`,
which aren't very useful. Remember how we said statements don't return a value?
Well, that's the purpose of unit in this case. The semicolon turns any
expression into a statement by throwing away its value and returning unit
instead.

There's one more time in which you won't see a semicolon at the end of a line
of Rust code. For that, we'll need our next concept: functions
works because `if` is an expression. The value of the expression is the
value of the last expression in whichever branch was chosen. An `if` without an
`else` always results in `()` as the value
.