1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}"); // x is 12
    }

    println!("The value of x is: {x}"); // x is 6
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// shadowing
{
    let x = 5;
    let x = x + 1;
}


// mut
{
    let mut x = 5;
    x = x + 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// shadowing: 깔끔한 네이밍 유지 가능하다.
{
  let spaces = "   ";
  let spaces = spaces.len();
}

// mut: 컴파일 에러
{
  let mut spaces = "   ";
  spaces = spaces.len() // error[E0308]: mismatched types
}

// immutable: 더럽다.
{
  let spaces_str = "    ";
  let spaces_len = spaces_str.len();
}

1
2
3
4

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

1
2
3
4

fn main() {
    let t = true;
    let f: bool = false; // with explicit type annotation
}

1
2
3
4
5

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 다른 타입들을 사용할 경우
{
  let tup: (i32, f64, u8) = (500, 6.4, 1);
}

// 단일 타입을 사용할 경우
{
    let tup = (500, 6.4, 1); 
    let (x, y, z) = tup; // 패턴 매칭 destructuring
}

1
2
3
4
5

{
    let x: (i32, f64, u8) = (500, 6.4, 1);
    let five_hundred = x.0;
    let six_point_four = x.1;
}

1
2
3
4

{
   let a = [1, 2, 3, 4, 5];

}

1
2
3
4
5
6
7

{
  let months = ["January", "February", "March", "April", "May", "June", "July",
                "August", "September", "October", "November", "December"];
  
  let first = months[0];
  let second = months[1];   
}

1
2
3
4
5
6
7

$ cargo run
   Compiling arrays v0.1.0 (file:///projects/arrays)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs
     Running `target/debug/arrays`
thread '<main>' panicked at 'index out of bounds: the len is 5 but the index is
 10', src/main.rs:6
note: Run with `RUST_BACKTRACE=1` for a backtrace.

1
2
3
4
5
6

// statement
{
  let y = 6;
  let x = (let y = 6); // compile error, return value가 없기 때문
}
// 

1
2
3
4
5
6
7
8

fn main() {
  let x = 5;

  let y = {
    let x = 3;
    x + 1 // expression, evaluated return value
  }; // let y = 4;
}

1
2
3

fn five() -> i32 {
    5
}

1
2
3

fn five() -> i32 {
    5;
}

1
2
3

fn five() -> () {
    5;
}

1
2
3
4

fn main() {
    // I’m feeling lucky today.
    let lucky_number = 7;
}

1
2
3
4
5
6
7
8

fn main() {
    let number = 3;

    // mismatched types
    if number {
        println!("number was three");
    }
}

1
2
3
4
5
6
7

{
  let number = if condition {
      5
  } else {
      6
  };
}

1
2
3
4
5
6
7

{
    let number = if condition {
        5
    } else {
        "six"
    };  
}

1
2
3
4
5

{
  loop {
    do_something();
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{
  let mut cnt = 0;
  let result = loop {
    cnt += 1;
    if cnt == 10 {
      break cnt * 2;
    }
  };
  
  assert_eq!(result, 20);
}

1
2
3
4
5
6
7
8

{
  let mut i = 0;

  while i < 5 {
    do_something();
    i = i + 1
  }
}

1
2
3
4
5
6
7

{
  let arr = [1,2,3,4,5];

  for e in arr.iter() {
    do_somethin(e);
  }
}

1
2
3
4
5

{
  for n in (1..4).rev() {
    do_something();
  }
}

1
2
3
4
5

{
  let mut s = String::from("hello");
  s.push_str(", minwook :)");
  // "hello, minwook :)"
}

1
2
3
4
5
6

{
    let s = String::from("hello"); // s는 여기서부터 유효합니다

    // s를 가지고 뭔가 합니다
}                                  // 이 스코프는 끝났고, s는 더 이상 
                                   // 유효하지 않습니다

1
2

let s1 = String::from("hello");
let s2 = s1;

1
2
3
4
5

{
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{s1}, {s2}"); // compile error
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

error[E0382]: use of moved value: `s1`
 --> src/main.rs:4:27
  |
3 |     let s2 = s1;
  |         -- value moved here
4 |     println!("{}, world!", s1);
  |                            ^^ value used here after move
  |
  = note: move occurs because `s1` has type `std::string::String`,
which does not implement the `Copy` trait

1
2
3
4
5

{
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{s2}"); // "hello"
}

1
2
3
4

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2); // s1 = hello, s2 = hello

1
2
3
4
5

{
  let x = 5;
  let y = x;
  println!("x = {}, y = {}", x, y);  // x = 5, y = 5
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() {
    let s = String::from("hello");  // s가 스코프 안으로 들어왔습니다.

    takes_ownership(s);             // s의 값이 함수 안으로 이동했습니다.
                                    // 그리고 여기 부터는 더이상 유효하지 않습니다.
    let x = 5;                      // x가 스코프 안으로 들어왔습니다.

    makes_copy(x);                  // x가 함수 안으로 이동했습니다만,
                                    // i32는 Copy가 되므로, x를 이후에 계속
                                    // 사용해도 됩니다.

} // 여기서 x는 스코프 밖으로 나가고, s도 그 후 나갑니다. 하지만 s는 이미 이동되었으므로,
  // 별다른 일이 발생하지 않습니다.

fn takes_ownership(some_string: String) { // some_string이 스코프 안으로 들어왔습니다.
    println!("{}", some_string);
} // 여기서 some_string이 스코프 밖으로 벗어났고 `drop`이 호출됩니다. 메모리는
  // 해제되었습니다.

fn makes_copy(some_integer: i32) { // some_integer이 스코프 안으로 들어왔습니다.
    println!("{}", some_integer);
} // 여기서 some_integer가 스코프 밖으로 벗어났습니다. 별다른 일은 발생하지 않습니다.

1
2

hello
5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

fn main() {
    let s1 = gives_ownership();         // gives_ownership은 반환값을 s1에게
                                        // 이동시킵니다.

    let s2 = String::from("hello");     // s2가 스코프 안에 들어왔습니다.

    let s3 = takes_and_gives_back(s2);  // s2는 takes_and_gives_back 안으로
                                        // 이동되었고, 이 함수가 반환값을 s3으로도
                                        // 이동시켰습니다.

} // 여기서 s3는 스코프 밖으로 벗어났으며 drop이 호출됩니다. s2는 스코프 밖으로
  // 벗어났지만 이동되었으므로 아무 일도 일어나지 않습니다. s1은 스코프 밖으로
  // 벗어나서 drop이 호출됩니다.

fn gives_ownership() -> String {             // gives_ownership 함수가 반환 값을
                                             // 호출한 쪽으로 이동시킵니다.

    let some_string = String::from("hello"); // some_string이 스코프 안에 들어왔습니다.

    some_string                              // some_string이 반환되고, 호출한 쪽의
                                             // 함수로 이동됩니다.
}

// takes_and_gives_back 함수는 String을 하나 받아서 다른 하나를 반환합니다.
fn takes_and_gives_back(a_string: String) -> String { // a_string이 스코프
                                                      // 안으로 들어왔습니다.

    a_string  // a_string은 반환되고, 호출한 쪽의 함수로 이동됩니다.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

fn main() {
    let s1 = String::from("hello");
    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len()함수는 문자열의 길이를 반환합니다.

    (s, length)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fn main() {
  let s1 = String::from("hello");
  let len = calculate_length(&s1);
  
  println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
} // 여기서 s는 스코프 밖으로 벗어났습니다. 하지만 가리키고 있는 값에 대한 소유권이 없기
  // 때문에, 아무런 에러도 발생하지 않습니다. 참조자 s가 drop됩니다.

1
2
3
4
5
6
7
8

fn main() {
  let s1 = String::from("hello");
  modify(&s1);
}

fn modify(s: &String) {
  s.push_str(", minwook");
}

1
2
3
4
5
6
7

error[E0596]: cannot borrow `*s` as mutable, as it is behind a `&` reference
 --> src/main.rs:7:3
  |
6 | fn modify(s: &String) {
  |              ------- help: consider changing this to be a mutable reference: `&mut String`
7 |   s.push_str(", minwook");
  |   ^^^^^^^^^^^^^^^^^^^^^^^ `s` is a `&` reference, so the data it refers to cannot be borrowed as mutable

1
2
3
4
5
6
7
8

fn main() {
  let mut s1 = String::from("hello");
  modify(&mut s1);
}

fn modify(s: &mut String) {
  s.push_str(", minwook");
}

1
2
3
4
5
6
7

{
  let mut s = String::from("hello");
  let r1 = &mut s;
  let r2 = &mut s;
}

// error[E0499]: cannot borrow `s` as mutable more than once at a time.

1
2
3
4
5
6

let mut s = String::from("hello"):
{
  let r1 = &mut s;
} // 여기서 r1은 스코프 밖으로 벗어났으므로, 우리는 아무 문제 없이 새로운 참조자를 만들 수 있습니다.

let r2 = &mut s;

1
2
3
4

let mut s = String::from("hello");

let r1 = &s;
let r2 = &s; // ok

1
2
3
4
5

let mut s = String::from("hello");

let r1 = &s;
let r2 = &mut s;
// error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable.

1
2
3
4
5

let mut s = String::from("hello");

let r2 = &mut s;
let r1 = &s;
// error[E0502]: cannot borrow `s` as immutable because it is also borrowed as mutable

1
2
3
4
5
6
7
8
9

fn main() {
  let dangle_ref = dangle();
}

fn dangle() -> &String {
  let s = String::from("hello");

  &s
} // s는 }를 벗어나는 시점에 free되므로, &s는 dangling reference입니다.

1
2
3
4
5
6

error[E0106]: missing lifetime specifier

...

help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from. 
(해석: 이 함수의 반환 타입은 빌린 값을 포함하고 있는데, 빌려온 실제 값은 없습니다.)

1
2
3
4
5

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

1

fn first_word(s: &String) -> ?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// String 파라미터의 바이트 인덱스 값을 반환하는 first_word 함수
fn first_word(s: &String) -> usize {
  // 공백인지 확인할 필요가 있기 때문에, String은 as_bytes 메소드를 이용하여 바이트 배열로 변환.
  let bytes = s.as_bytes();

  for (i, &item) in bytes.iter().enumerate() {
    // 공백 문자를 찾았다면, 이 위치를 반환합니다.
      if item == b' ' {
          return i;
      }
  }

  s.len()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word는 5를 갖게 될 것입니다.

    s.clear(); // 이 코드는 String을 비워서 ""로 만들게 됩니다.

    // word는 여기서 여전히 5를 갖고 있지만, 5라는 값을 의미있게 쓸 수 있는 스트링은 이제 없습니다.
    // word는 이제 완전 유효하지 않습니다!
}

1
2
3

fn second_word(s: &String) -> (usize, usize) {

}

1
2
3
4
5
6
7
8
9

let s = String::from("hello world");

let hello = &s[0..5]; // 0, 1, 2, 3, 4
// let hello = &s[..5];와 동일

let world = &s[6..11]; // 6, 7, 8, 9, 10
// let len = s.len();
// let slice = &s[3..len]; 와 동일
// let slice = &s[3..]; 와 동일

1
2
3
4
5
6

let s = String::from("hello");

let n = s.len();

let slice = &s[0..n];
let slice = &s[..];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

1
2
3
4
5
6
7
8
9

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // Error!

    println!("the first word is: {}", word);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

17:6 error: cannot borrow `s` as mutable because it is also borrowed as
            immutable [E0502]
    s.clear(); // Error!
    ^
15:29 note: previous borrow of `s` occurs here; the immutable borrow prevents
            subsequent moves or mutable borrows of `s` until the borrow ends
    let word = first_word(&s);
                           ^
18:2 note: previous borrow ends here
fn main() {

}

1

let s = "Hello, world!"; // s는 &str 타입

1

fn first_word(s: &str) -> &str {

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

fn main() {
    let my_string = String::from("hello world");

    // first_word가 `String`의 슬라이스로 동작합니다.
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word가 스트링 리터럴의 슬라이스로 동작합니다.
    let word = first_word(&my_string_literal[..]);

    // 스트링 리터럴은 또한 스트링 슬라이스이기 때문에,
    // 아래 코드도 슬라이스 문법 없이 동작합니다!
    let word = first_word(my_string_literal);
}

1
2
3
4
5
6

struct User {
  name: String,
  email: String,
  sign_in_count: u64,
  is_active: bool,
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#[derive(Debug)]
struct User {
  name: String,
  email: String,
  sign_in_count: u64,
  is_active: bool,
}

fn main() {

    let mut user = User {
      email: String::from("leoo_is_cool@leoo.com"),
      name: String::from("leoo.j"),
      is_active: true,
      sign_in_count: 1,
    };
    user.is_active = false;    
    println!("{:#?}", user);
}

1
2
3
4
5
6
7
8

fn build_user(email: String, name: String) -> User {
  User {
    email, // email: email과 동일
    name, // name: name과 동일
    is_actieve: true,
    sign_in_count: 1,
  }
}

1
2
3
4
5
6

let user2 = User {
    email: String::from("another@example.com"),
    name: String::from("anotherusername567"),
    is_active: user1.is_active,
    sign_in_count: user1.sign_in_count,
};

1
2
3
4
5

let user2 = User {
    email: String::from("another@example.com"),
    name: String::from("anotherusername567"),
    ..user1
};

1
2

Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)

1
2
3
4
5
6
7
8
9

extern crate assert_type_eq;

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
  let black = Color(0,0,0);
  let origin = Point(0,0,0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct User {
    username: &str, // 참조(reference) 데이터
    email: &str, // // 참조(reference) 데이터
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user1 = User {
        email: "someone@example.com",
        username: "someusername123",
        active: true,
        sign_in_count: 1,
    };
}

// error[E0106]: missing lifetime specifier

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

fn main() {
    let length1 = 50;
    let width1 = 30;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(length1, width1)
    );
}

fn area(length: u32, width: u32) -> u32 {
    length * width
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

fn main() {
    let rect1 = (50, 30);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1 // 명확하지 못함.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

struct Rectangle {
  length: u32,
  width: u32,
}

fn main() {
  let r1 = Rectangle {
    length: 50,
    width: 30,
  };
  println!(
    "The area of the rectangle is {} square pixels.",
    area(&r1)
  );
}

fn area(rectangle: &Rectangle) -> u32 {
  rectangel.length * rectangle.width // explicit하게 필드들 사용가능
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#[derive(Debug)]
struct Rectangle {
    length: u32,
    width: u32,
}

fn main() {
    let rect1 = Rectangle { length: 50, width: 30 };

    // 1. print struct
    println!("rect1 is {:?}", rect1); 
    // rect1 is Rectangle { length: 50, width: 30 }
    
    // 2. pretty print struct
    println!("rect1 is {:#?}", rect1); 
    // rect1 is Rectangle {
    //  length: 50,
    //  width: 30
    // }
}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#[derive(Debug)]
struct Rectangle {
    length: u32,
    width: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.length * self.width
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

impl Rectangle {
    fn area(&self) -> u32 {
        self.length * self.width
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.length > other.length && self.width > other.width
    }
}

fn main() {
    let rect1 = Rectangle { length: 50, width: 30 };
    let rect2 = Rectangle { length: 40, width: 10 };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); 
    // Can rect1 hold rect2? true
}

1
2
3
4
5
6
7
8
9

impl Rectangle {
  fn square(size: u32) -> Rectangle {
    Rectangle { length: size, width: size}
  }
}

fn main() {
  let sq = Rectangle::square(3);
}

1
2
3
4

enum IpAddrKind {
  V4,
  V6,
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

struct Ipv4Addr {
  address : (u8, u8, u8, u8),
  ...
}

struct Ipv6Addr {
  address : String,
  ...
}

enum IpAddr {
  V4(Ipv4Addr),
  V6(Ipv6Addr),
}

1
2
3
4
5
6

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Message {
    fn call(&self) {
        println!("called");
    }
}

struct QuitMessage; // 유닛 구조체
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 튜플 구조체
struct ChangeColorMessage(i32, i32, i32); // 튜플 구조체

fn main() {
    let m = Message::Write(String::from("hello"));
    m.call();
}