Rust Pitfall: Using Semicolons (;)
Rust๋ฅผ ์ฒ์ ์์ํ๋ ์ ์ฅ์์ ๋นํฉ์ค๋ฌ์ธ ๋งํ ์ ์ค ํ๋๋ก ์ธ๋ฏธ์ฝ๋ก ์ ์ฌ์ฉ์ ๋ค ์ ์๋ค. ๋น์ทํ ์๊ธฐ์ ๋ฑ์ฅํ Swift๋ Go ๊ฐ์ ์ธ์ด์์๋ ๋ฌธ์ฅ ๋์ ์ธ๋ฏธ์ฝ๋ก ์ ์ฐ์ง ์๋ ๊ฒ๊ณผ ๋ค๋ฅด๊ฒ, Rust๋ C๋ Java์ฒ๋ผ ์ธ๋ฏธ์ฝ๋ก (;)์ด ํ์์ธ ์ธ์ด์ ์ํ๋ค. Python์ด๋ Ruby ์ดํ์ ๋ฑ์ฅํ ์ธ์ด๋ค์ด ๋์ฒด๋ก ์ธ๋ฏธ์ฝ๋ก ์ ๋นผ๋ ์ชฝ์ผ๋ก ๋ฌธ๋ฒ์ ์ ํ๋ ๊ฒฝํฅ์ด ์์๋ ๊ฑธ ์๊ฐํด๋ณด๋ฉด ์กฐ๊ธ ํน์ดํ ์ ์ผ๋ก ๋ณผ ์ ์๊ฒ ๋ค.
์์ ๋งํ ๋๋ก ๋ฌธ์ฅ ๋์ ์ธ๋ฏธ์ฝ๋ก ์ ์๋ตํ ์ ์๊ธฐ ๋๋ฌธ์, ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ ๋น์ฐํ ์ปดํ์ผ ์๋ฌ๊ฐ ๋๋ค. (Rust Playpen)
fn main() { let a = 1 let b = 2 println!("{} + {} = {}", a, b, a + b) }
anon:3:5: 3:8 error: expected one of `.`, `;`, or an operator, found `let` anon:3 let b = 2 ^~~
ํ์ง๋ง ์ฌ๊ธฐ์๋ถํฐ๋ถํฐ๊ฐ ๋นํฉ์ค๋ฌ์ด ์ง์ ์ธ๋ฐ, ์๋ ์ฝ๋๋ ๋ฌธ์ ์์ด ์ปดํ์ผ์ ํต๊ณผํ๋ค.
fn main() { let a = 1; let b = 2; println!("{} + {} = {}", a, b, a + b) }
๋ง์ง๋ง ๋ฌธ์ฅ์ ํํด์ ์ธ๋ฏธ์ฝ๋ก ์ ์๋ตํ ์ ์๋ ๊ฑธ๊น? ์ฝ๋๋ฅผ ๋ค์์ฒ๋ผ ๋ฐ๊ฟ ๋ณด๋ฉด ๋๋์ฑ ํผ๋์ค๋ฌ์ด ๊ฒฐ๊ณผ๋ฅผ ๋ณผ ์ ์๋ค. (Rust Playpen)
fn main() { let a = 1; let b = 2; println!("{} + {} = {}", a, b, a + b); a + b }
anon:5:5: 5:10 error: mismatched types: expected `()`, found `_` (expected (), found integral variable) [E0308] anon:5 a + b ^~~~~ anon:5:5: 5:10 help: see the detailed explanation for E0308 error: aborting due to previous error
์๋ฌ ๋ฉ์์ง๋ฅผ ์ ๋ณด๋ฉด ์ด๊ฒ ์ธ๋ฏธ์ฝ๋ก ์ด ๋น ์ก๋ค๋ ์๊ธฐํ๊ณค ์กฐ๊ธ ๋ค๋ฅธ ๊ฒ ๊ฐ๋ค. ํ์ ์ด ์ ๋ง๋๋ค๊ณ ? ()๋ ๋ ๋ญ์ง? ๊ฒฐ๋ก ๋ถํฐ ์๊ธฐํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ท์น๋ค ๋๋ฌธ์ด๋ค.
Rust์์ ๊ฑฐ์ ๋๋ถ๋ถ์ ๋ฌธ์ฅ์ ์์์ผ๋ก ์ทจ๊ธ๋๋ค.
ํํ 3ํญ ์ฐ์ฐ์๋ผ๊ณ ๋ถ๋ฆฌ๋ a ? b : c ๊ผด์ ์กฐ๊ฑด ๋ฌธ๋ฒ์ด Rust์๋ ์๋๋ฐ, if๋ match์ ๊ฐ์ ๋ฌธ์ฅ์ด ๊ทธ๋๋ก ์์์ผ๋ก ๊ฐ์ฃผ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๋ค์ ๋งํด ์๋์ ๊ฐ์ ์ฝ๋๋ฅผ ์งค ์ ์๋ค.
println!("{}", if a % 2 == 0 { "even" } else { "odd" });
์ธ๋ฏธ์ฝ๋ก ์ ์ฌ๋ฌ ๋ฌธ์ฅ์ ์ฐ๊ฒฐํ๋ค.
๋ค๋ฅธ ์ธ์ด์์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ๋จ์ํ ๋ฌธ์ฅ์ ๋๋ธ๋ค๋ ์๋ฏธ๋ง์ ๊ฐ์ง๋ ๋ฐ๋ฉด, Rust์์๋ ์ฌ๊ธฐ์ ๋ง๋ถ์ฌ, ์ธ๋ฏธ์ฝ๋ก ์ผ๋ก ์ฐ๊ฒฐ๋ ๋ฌธ์ฅ๋ค์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ฌธ์ฅ์ ์ ์ฒด ๋ฌธ์ฅ์ '๊ฒฐ๊ณผ ๊ฐ'์ผ๋ก ํ๋ ๊ธฐ๋ฅ์ด ์๋ค.1 ์งง๊ฒ ์๋ฅผ ๋ค๋ฉด, a; b๋ ๋จผ์ a๋ฅผ ์คํํ ๋ค ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฒ๋ฆฌ๊ณ , b๋ฅผ ์คํํ ๊ฒฐ๊ณผ์ ๊ฐ์ ๊ฐ์ด ๋๋ค. ๊ทธ๋์ ์ฌ๋ฌ ๋ฌธ์ฅ์ { ... } ๋ธ๋ก์ผ๋ก ๋ฌถ์ผ๋ฉด, ์ด ๋ธ๋ก์ ๋ง์ง๋ง ๋ฌธ์ฅ์ ๊ฐ์ด ๋ธ๋ก ๋ฐ์ผ๋ก '๋ฆฌํด'๋๋ ํจ๊ณผ๊ฐ ๋๋ค.
์ด๊ฑธ ์์ฉํ๋ฉด ์๋์ ๊ฐ์ ์ฝ๋๋ฅผ ์ฐ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
let numbers = { let mut vec = vec![]; for i in (0..5) { vec.push(i); } vec };
a;์ a; ()๊ณผ ๊ฐ๋ค.
์ฌ๊ธฐ์ ()์ ์ผ๋ช unit ํ์ ์ด๋ผ ๋ถ๋ฆฌ๋ ๊ฒ์ผ๋ก, C๋ Java์ void ํ์ ๊ณผ ๋น์ทํ ์ญํ ์ ๋งก๋๋ค.2 ๋ํ, ์ ์์ ์์์ main() ํจ์์ฒ๋ผ ๋ฆฌํด ๊ฐ์ด ์๋ ํจ์๋ ()์ ๋ฆฌํดํ๋ ๊ฒ์ผ๋ก ์ทจ๊ธ๋๋ค.
ํจ์์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ฌธ์ฅ์ด ์ธ๋ฏธ์ฝ๋ก ์ผ๋ก ๋๋์ง ์๋๋ค๋ฉด, ๊ทธ ๋ฌธ์ฅ์ ์๋ฌต์ ์ผ๋ก ํจ์์ ๋ฆฌํด ๊ฐ์ด ๋๋ค.
๋ฐ๋ผ์ ์๋์ ๊ฐ์ ํจ์๋ฅผ
fn add(a: i32, b: i32) -> i32 { return a + b; }
์ด๋ ๊ฒ ์ค์ฌ ์ธ ์ ์๊ฒ ๋๋ค.
fn add(a: i32, b: i32) -> i32 { a + b }
์ด์ ์์ ์์ ๋ฅผ ๋ค์ ๋์ง์ด๋ณด์. ๋ ๋ฒ์งธ ์ฝ๋์์ println!("{} + {} = {}", a, b, a + b)์ด ๋ฌธ์ ์์ด ํต๊ณผ๋๋ ๊ฒ์ println!(..)์ ๊ฒฐ๊ณผ ๊ฐ์ด ()์ด๊ณ , ์ด๊ฒ์ด main() ํจ์์ ๋ฆฌํด ํ์ ์ธ ()์ ๊ฐ์๊ธฐ ๋๋ฌธ์ด๋ค. ์ธ ๋ฒ์งธ ์ฝ๋๊ฐ ์คํจํ๋ ๊ฒ ๋ํ ๊ฐ์ฅ ๋ง์ง๋ง ๋ฌธ์ฅ์ธ a + b์ ํ์ ์ด ()๊ฐ ์๋ ๋ฌด์ธ๊ฐ์ด๊ณ 3, ์ด๊ฒ์ด main()์ ๋ฆฌํด ํ์ ๊ณผ ๋ง์ง ์์์์๋ค.
์ผํ ์ค์๋ก ์ฝ์งํ๊ธฐ ๋ฑ ์ข์ ๋ฌธ๋ฒ์ด๋ผ๋ ์๊ฐ์ด ๋ค์ง๋ง, ์ค์๋ฅผ ํด๋ Rust๊ฐ ๊ฐํ์ ์ธ์ด์ด๊ธฐ ๋๋ฌธ์ ํ์ ์์คํ ์ ์ํด ์ปดํ์ผ๋ฌ๊ฐ ์ก์ ์ค ๊ฑฐ๋ผ๊ณ ๋ค๋ค ์๊ฐํ๋ ๊ฒ ๊ฐ๋ค. ๋๋ค์์ ๊ด์ฉ์ ์ธ Rust ์ฝ๋๊ฐ ์ด ํน์ฑ๋ค์ ์ ๊ทน์ ์ผ๋ก ์ฌ์ฉํ๋ Rust๋ฅผ ๋ฐฐ์ฐ๊ณ ์ ํ๋ ์ฌ๋์ด๋ผ๋ฉด ์ด๋ฐ ์ฝ๋๋ค์ ์ต์ํด์ง๋ ๊ฒ์ด ์ข๊ฒ ๋ค.
๋ง์ฝ C์ ์ต์ํ๋ค๋ฉด C์ ์ฝค๋ง ์ฐ์ฐ์(,)๊ฐ ์ด๊ฒ๊ณผ ๋น์ทํ๋ค๋ ๊ฑธ ๋์น์ฑ์ ๊ฒ์ด๋ค.ย โฉ๏ธ
ํ์ง๋ง void ํ์ ๊ณผ ๋ค๋ฅธ ์ ์ด ํ๋ ์๋๋ฐ, C๋ Java์์ void ํ์ ์ ๊ฐ์ ์กด์ฌํ์ง ์์ง๋ง, Rust์ () ํ์ ์ ()์ด๋ผ๋ ๊ฐ์ ๋ฑ ํ๋ ๊ฐ๋๋ค. ๊ต์ฅํ ์ธ๋ชจ ์์ด ๋ณด์ด์ง๋ง ์์ธ๋ก Option<T>๋ Result<T, E> ํ์ ๊ฐ์ ๊ฑธ ์ธ ๋ ์ ์ฉํ๊ฒ ์จ ๋จน์ ์ ์๋ค. ์์ธํ ์๊ธฐ๋ ์ด ํฌ์คํ ์ ์ฃผ์ ๋ฅผ ๋ฒ์ด๋๋ ๋ค์ ๊ธฐํ์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ๋ค.ย โฉ๏ธ
์ "()๊ฐ ์๋ ๋ฌด์ธ๊ฐ"๋ผ๊ณ ํํํ๋๋ฉด, Rust๋ ํ์ ์ถ๋ก ์ ํ๋ ์ธ์ด์ด๊ณ , Rust์ ์ ์ ๋ฆฌํฐ๋ด์ ๋ฌธ๋งฅ์ ๋ฐ๋ผ์ ์ฌ๋ฌ ๋ค๋ฅธ ํ์ ์ผ๋ก ์ถ๋ก ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ์๋ฌ ๋ฉ์์ง์์ "found integral variable"์ด๋ผ๊ณ ๋ฌ ์ด์ ์ด๊ธฐ๋ ํ๋ค. ์ด์ ๋ํด์๋ ๋ค๋ฅธ ํฌ์คํ ์์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ๋ค.ย โฉ๏ธ










