บทนำ - ยินดีต้อนรับสู่ Rust! 🦀

Rust คืออะไร?

Rust เป็นภาษาโปรแกรมระดับ Systems Programming ที่มุ่งเน้น 3 เรื่องหลัก: ความปลอดภัย (Safety), ความเร็ว (Speed), และ ความสามารถในการทำงานพร้อมกัน (Concurrency) โดยไม่ต้องมี Garbage Collector

🧠 ปรัชญาของ Rust (The Three Pillars)

Rust ถูกออกแบบมาเพื่อแก้ปัญหา Trade-off เดิมๆ ที่ว่า “ถ้าอยากได้ความปลอดภัย ต้องยอมแลกด้วยความเร็ว” ด้วย 3 เสาหลัก:

1. Memory Safety โดยไม่มี Garbage Collector

Rust ตรวจสอบความถูกต้องของหน่วยความจำตั้งแต่ตอน Compile (ผ่านระบบ Ownership) ไม่ต้องมี GC มาถ่วงตอน Runtime

2. Zero-Cost Abstractions

คุณสามารถเขียนโค้ด High-level (เช่น Iterators, Closures, Generics) ที่อ่านง่าย แต่เมื่อ Compile แล้วจะได้ Machine Code ที่เร็วเท่ากับการเขียนแบบ Low-level ด้วยมือ

📌 กฎเหล็ก: “สิ่งที่คุณไม่ได้ใช้ คุณไม่ต้องจ่าย และสิ่งที่คุณใช้ คุณไม่สามารถเขียนเองด้วยมือให้ดีกว่าที่ภาษาทำให้ได้”

3. Fearless Concurrency

Rust Compiler ช่วยป้องกัน Data Races ตั้งแต่ตอนเขียนโค้ด ทำให้นักพัฒนา “กล้า” เขียนโปรแกรมที่ทำงานขนานกัน (Multi-threading) ได้อย่างเต็มประสิทธิภาพโดยไม่ต้องกลัวบั๊กที่หาเจอยาก

🆚 เปรียบเทียบกับภาษาอื่น

💡 สรุป: Rust ให้ความเร็วเท่า C/C++ แต่ปลอดภัยเท่า Go/Java โดยไม่ต้องมี Garbage Collector!

ทำไมต้องเรียน Rust?

นอกเหนือจากความเทพทางเทคนิคแล้ว นี่คือเหตุผลที่คุณควรลงทุนเวลากับภาษานี้:

Rust เหมาะกับงานอะไร?

🌍 ใครใช้ Rust?

บริษัทชั้นนำระดับโลกเปลี่ยนมาใช้ Rust เพราะความปลอดภัยและประสิทธิภาพ:

💡 รู้หรือไม่? Discord เคยมีปัญหา latency spike ทุก 2 นาที เมื่อเปลี่ยนจาก Go เป็น Rust ปัญหาหายไปเลย!

📜 ประวัติความเป็นมา

Graydon Hoare พนักงานของ Mozilla เริ่มพัฒนา Rust เป็นโปรเจกต์ส่วนตัวในปี 2006 (ตั้งชื่อตามเชื้อราสนิมที่มีความทนทาน) ก่อนที่ Mozilla จะเห็นศักยภาพและสนับสนุนอย่างเป็นทางการในปี 2009

🗓️ Rust Timeline

หนังสือเล่มนี้มีอะไรบ้าง?

📊 ภาพรวม

🎯 Edition

หนังสือเล่มนี้ใช้ Rust Edition 2024 ซึ่งเป็นเวอร์ชันล่าสุด

หนังสือเล่มนี้สำหรับใคร?

หนังสือเล่มนี้เขียนขึ้นสำหรับ ผู้เริ่มต้น ที่:

• 🆕 ไม่เคยเขียนโปรแกรมมาก่อน - เราจะอธิบายทุกอย่างตั้งแต่พื้นฐาน
• 🔄 มีประสบการณ์ภาษาอื่น - และอยากเรียน Rust

โครงสร้างหนังสือ

หนังสือแบ่งออกเป็น 5 ส่วน:

Part 1: พื้นฐาน (บทที่ 1-4)

เริ่มต้นจากการติดตั้ง เขียน Hello World ไปจนถึงพื้นฐานการเขียนโปรแกรม

Part 2: Core Concepts (บทที่ 5-9)

หัวใจสำคัญของ Rust - Ownership ⭐, Structs, Enums, Error Handling

Part 3: Advanced Concepts (บทที่ 10-14)

Generics, Traits, Lifetimes, Modules, Testing, Iterators, Smart Pointers

Part 4: Concurrency & Advanced (บทที่ 15-18)

การเขียนโปรแกรมแบบ concurrent, async/await, unsafe, macros

Part 5: Real World (บทที่ 19-20)

Web Development และ Final Project - สร้างโปรเจกต์จริง

วิธีใช้หนังสือเล่มนี้

💡 คำแนะนำ

1. 📚 อ่านตามลำดับ - แต่ละบทต่อยอดจากบทก่อนหน้า
2. ⌨️ ลงมือทำ - พิมพ์โค้ดเอง อย่า copy-paste
3. 🔬 ทดลอง - แก้โค้ดดู ลองผิดลองถูก
4. ✍️ ทำแบบฝึกหัด - ท้ายบทจะมีแบบฝึกหัดให้ทำ
5. ❓ ทำ Quiz - ทดสอบความเข้าใจ

📝 สัญลักษณ์ที่ใช้

ตลอดทั้งเล่ม คุณจะเห็นกล่องข้อความเหล่านี้:

📌 หมายเหตุ: ข้อมูลเพิ่มเติมที่น่าสนใจ

💡 เคล็ดลับ: คำแนะนำที่จะทำให้เขียนโค้ดได้ดีขึ้น

⚠️ คำเตือน: สิ่งที่ควรระวัง

🎯 ลองทำดู: แบบฝึกหัดให้ลองทำ

เครื่องมือที่ต้องการ

ก่อนเริ่มเรียน ติดตั้งสิ่งเหล่านี้:

พร้อมแล้วหรือยัง?

มาเริ่มการเดินทางกับ Rust กันเลย! 🚀

👉 ไปบทที่ 1: Getting Started - เริ่มต้นกับ Rust

☕ สนับสนุนผู้เขียน

ถ้าหนังสือเล่มนี้มีประโยชน์และช่วยให้คุณเข้าใจ Rust มากขึ้น คุณสามารถเลี้ยงกาแฟผมได้ที่: Buy Me a Coffee ☕

บทที่ 1: Getting Started - เริ่มต้นกับ Rust 🚀

ยินดีต้อนรับสู่การเขียนโปรแกรมด้วย Rust! ในบทนี้เราจะ:

• ✅ ติดตั้ง Rust บนคอมพิวเตอร์ของคุณ
• ✅ เขียนโปรแกรม “Hello, World!”
• ✅ เรียนรู้พื้นฐานการใช้ Cargo

สิ่งที่จะได้เรียนรู้

เริ่มกันเลย!

👉 การติดตั้ง Rust

การติดตั้ง Rust

ติดตั้งด้วย rustup

rustup เป็นเครื่องมืออย่างเป็นทางการสำหรับติดตั้งและจัดการ Rust

🛠️ Rust Toolchain Overview

+-------------------------------------------------------------------+
|                  Rust Development Toolchain                       |
+-------------------------------------------------------------------+
|                                                                   |
|  rustup (Toolchain Manager)                                       |
|  +-- rustc (Compiler)      <-- compile .rs to executable          |
|  +-- cargo (Build Tool)    <-- manage project + dependencies      |
|  +-- rustfmt (Formatter)   <-- auto format code                   |
|  +-- clippy (Linter)       <-- best practices suggestions         |
|  +-- rust-docs (Docs)      <-- offline documentation              |
|                                                                   |
|  IDE Setup (Recommended)                                          |
|  +-------------------------------------------------------+        |
|  |  VS Code + rust-analyzer extension                    |        |
|  |  * Auto-complete                                      |        |
|  |  * Error highlighting                                 |        |
|  |  * Go to definition                                   |        |
|  |  * Inline type hints                                  |        |
|  +-------------------------------------------------------+        |
|                                                                   |
+-------------------------------------------------------------------+

สำหรับ Windows

1. ดาวน์โหลด rustup จาก https://rustup.rs
2. เปิดไฟล์ที่ดาวน์โหลดมาและทำตามขั้นตอน
3. อาจต้องติดตั้ง Visual Studio Build Tools ด้วย

สำหรับ macOS และ Linux

เปิด Terminal แล้วพิมพ์คำสั่ง:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

ทำตามขั้นตอนที่แสดงบนหน้าจอ

ตรวจสอบการติดตั้ง

หลังติดตั้งแล้ว ปิดและเปิด Terminal ใหม่ แล้วพิมพ์:

rustc --version

ถ้าติดตั้งสำเร็จ จะเห็นข้อความคล้ายๆ นี้:

rustc 1.83.0 (90b35a623 2024-11-26)

ลองตรวจสอบ Cargo ด้วย:

cargo --version

จะได้:

cargo 1.83.0 (5ffbef321 2024-10-29)

อัปเดต Rust

Rust ออกเวอร์ชันใหม่ทุก 6 สัปดาห์ อัปเดตได้ด้วย:

rustup update

เลือก IDE / Text Editor

แนะนำให้ใช้ VS Code พร้อม extension:

1. rust-analyzer - สำคัญมาก!
2. Even Better TOML
3. Error Lens

หรือจะใช้ RustRover ซึ่งเป็น IDE เฉพาะสำหรับ Rust จาก JetBrains ก็ได้

สรุป

✅ ติดตั้ง Rust ด้วย rustup
✅ ตรวจสอบด้วย rustc --version
✅ ติดตั้ง VS Code + rust-analyzer

👉 ต่อไป: Hello World

Hello, World!

มาเขียนโปรแกรมแรกกัน! ตามธรรมเนียมของการเรียนภาษาใหม่ เราจะเริ่มด้วย “Hello, World!”

สร้างไฟล์โปรแกรม

1. สร้างโฟลเดอร์สำหรับโปรเจกต์:

mkdir hello_world
cd hello_world

2. สร้างไฟล์ main.rs:

fn main() {
    println!("Hello, World!");
}

รันโปรแกรม

Compile และรัน:

rustc main.rs
./main        # บน macOS/Linux
.\main.exe    # บน Windows

ผลลัพธ์:

Hello, World!

🎉 ยินดีด้วย! คุณเพิ่งเขียนโปรแกรม Rust โปรแกรมแรก!

ทำความเข้าใจโค้ด

มาวิเคราะห์โค้ดทีละบรรทัด:

fn main() {
    println!("Hello, World!");
}

fn main()

fn main() {

• fn - คำสั่งสำหรับประกาศ function (ฟังก์ชัน)
• main - ชื่อฟังก์ชัน พิเศษเพราะเป็นจุดเริ่มต้นของโปรแกรม
• () - ไม่มี parameter (ค่าที่ส่งเข้ามา)
• { } - ขอบเขตของฟังก์ชัน (function body)

หมายเหตุ: ทุกโปรแกรม Rust ต้องมีฟังก์ชัน main เป็นจุดเริ่มต้น

println!("Hello, World!");

println!("Hello, World!");

• println! - เป็น macro (สังเกตเครื่องหมาย !) ใช้พิมพ์ข้อความออกหน้าจอ
• "Hello, World!" - string (ข้อความ) ที่จะพิมพ์
• ; - จบคำสั่ง (statement)

เคล็ดลับ: ใน Rust เครื่องหมาย ! หลังชื่อหมายถึง macro ไม่ใช่ function เราจะเรียนเรื่อง macro ในบทหลังๆ

รูปแบบการเขียน (Style)

Rust มีมาตรฐานการเขียนโค้ด:

1. Indentation - ใช้ 4 spaces (ไม่ใช่ tab)
2. ชื่อฟังก์ชัน - ใช้ snake_case เช่น my_function
3. วงเล็บปีกกา - เปิดในบรรทัดเดียวกับ function

// ✅ ถูกต้อง
fn main() {
    println!("Hello!");
}

// ❌ ไม่ใช่ style มาตรฐาน
fn main2()
{
    println!("Hello!");
}

ใช้คำสั่ง rustfmt เพื่อจัดรูปแบบโค้ดอัตโนมัติ:

rustfmt main.rs

ลองทำดู! 🎯

1. แก้โค้ดให้พิมพ์ชื่อของคุณ
2. ลองเพิ่ม println! อีกบรรทัด
3. ลองลบ ; ดูว่าเกิดอะไรขึ้น

สรุป

👉 ต่อไป: Cargo เบื้องต้น

Cargo เบื้องต้น

Cargo เป็นเครื่องมือจัดการโปรเจกต์และ package manager ของ Rust มาพร้อมกับ rustup

Cargo ทำอะไรได้บ้าง?

• 📦 สร้างโปรเจกต์ใหม่
• 🔨 Build โค้ด
• ▶️ รันโปรแกรม
• 📥 จัดการ dependencies (libraries ที่ใช้)
• 🧪 รัน tests
• 📖 สร้าง documentation

สร้างโปรเจกต์ใหม่

cargo new hello_cargo
cd hello_cargo

Cargo จะสร้างโครงสร้างโฟลเดอร์ให้:

hello_cargo/
+-- Cargo.toml
\-- src/
    \-- main.rs

ทำความเข้าใจโครงสร้าง

Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

• [package] - ข้อมูลโปรเจกต์
  • name - ชื่อโปรเจกต์
  • version - เวอร์ชัน
  • edition - Rust edition (ปกติใช้ปีล่าสุด)
• [dependencies] - รายการ libraries ที่ใช้

src/main.rs

fn main() {
    println!("Hello, world!");
}

โค้ดเริ่มต้นที่ Cargo สร้างให้

คำสั่ง Cargo ที่ใช้บ่อย

Build โปรเจกต์

cargo build

จะสร้างไฟล์ executable ใน target/debug/:

target/debug/hello_cargo

Build แบบ Release (เร็วกว่า)

cargo build --release

ไฟล์จะอยู่ใน target/release/ - เหมาะสำหรับ production

รันโปรแกรม

cargo run

คำสั่งนี้จะ build และ run ในคำสั่งเดียว สะดวกมาก!

   Compiling hello_cargo v0.1.0
    Finished dev [unoptimized + debuginfo] target(s) in 0.50s
     Running target/debug/hello_cargo
Hello, world!

ตรวจสอบโค้ด (ไม่ build)

cargo check

เร็วกว่า cargo build เพราะไม่สร้างไฟล์ executable ใช้ตรวจสอบว่าโค้ด compile ได้หรือไม่

เพิ่ม Dependencies

เมื่อต้องการใช้ library ภายนอก ให้เพิ่มใน Cargo.toml:

[dependencies]
rand = "0.8"

จากนั้นรัน:

cargo build

Cargo จะดาวน์โหลด library ให้อัตโนมัติ

หมายเหตุ: Library ของ Rust เรียกว่า crate หา crates ได้ที่ crates.io

สรุปคำสั่ง Cargo

ลองทำดู! 🎯

1. สร้างโปรเจกต์ใหม่ชื่อ my_project
2. แก้ไข main.rs ให้พิมพ์ข้อความอื่น
3. รันด้วย cargo run
4. ลอง cargo check ดู

สรุปบทที่ 1

ในบทนี้คุณได้เรียนรู้:

• ✅ ติดตั้ง Rust ด้วย rustup
• ✅ เขียนโปรแกรม Hello World
• ✅ ใช้งาน Cargo เบื้องต้น

👉 ต่อไป: บทที่ 2: Variables & Data Types

บทที่ 2: Variables & Data Types - ตัวแปรและชนิดข้อมูล

ในบทนี้เราจะเรียนรู้พื้นฐานที่สำคัญของทุกภาษาโปรแกรม นั่นคือ ตัวแปร และ ชนิดข้อมูล

สิ่งที่จะได้เรียนรู้

ทำไมต้องเข้าใจ?

ใน Rust ตัวแปรมีความพิเศษ:

1. Immutable by default - ตัวแปรเปลี่ยนค่าไม่ได้โดยปกติ
2. Type inference - Rust เดาชนิดข้อมูลให้ได้
3. Strongly typed - ต้องระบุชนิดข้อมูลให้ชัดเจน

เริ่มกันเลย!

👉 Mutability

Mutability - ความสามารถในการเปลี่ยนแปลงค่า

ประกาศตัวแปรด้วย let

ใน Rust เราใช้ let เพื่อประกาศตัวแปร:

fn main() {
    let x = 5;
    println!("x = {}", x);
}

ผลลัพธ์:

x = 5

ตัวแปรเปลี่ยนค่าไม่ได้ (Immutable)

ตัวแปรใน Rust เปลี่ยนค่าไม่ได้โดยปกติ!

fn main() {
    let x = 5;
    println!("x = {}", x);
    x = 6; // ❌ Error!
}

Error:

error[E0384]: cannot assign twice to immutable variable `x`

ทำไมถึงเป็นแบบนี้?

เพราะ immutable ทำให้โค้ดปลอดภัยและคาดเดาได้ง่ายกว่า เมื่อค่าไม่เปลี่ยน เราไม่ต้องกังวลว่าจะมีโค้ดส่วนอื่นแก้ไขค่าโดยไม่รู้ตัว

ตัวแปรเปลี่ยนค่าได้ (Mutable)

ถ้าต้องการเปลี่ยนค่า ให้เพิ่ม mut:

fn main() {
    let mut x = 5;
    println!("x = {}", x);

    x = 6; // ✅ OK เพราะใช้ mut
    println!("x = {}", x);
}

ผลลัพธ์:

x = 5
x = 6

เมื่อไหร่ควรใช้ mut?

✅ ใช้ mut เมื่อ:

• ต้องการสะสมค่า (เช่น ตัวนับ, ผลรวม)
• ต้องการแก้ไขข้อมูลใน loop

fn main() {
    let mut sum = 0;

    sum = sum + 1;
    sum = sum + 2;
    sum = sum + 3;

    println!("sum = {}", sum); // 6
}

❌ ไม่ต้องใช้ mut เมื่อ:

• ค่าไม่เปลี่ยนแปลง
• ต้องการความปลอดภัย

fn main() {
    let name = "Rust";
    let pi = 3.14159;

    println!("Learning {} with pi = {}", name, pi);
}

Shadowing (การซ่อนตัวแปร)

Rust อนุญาตให้ประกาศตัวแปรชื่อเดิมซ้ำได้:

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

    let x = x + 1; // สร้างตัวแปรใหม่ชื่อ x
    println!("x = {}", x); // 6

    let x = x * 2;
    println!("x = {}", x); // 12
}

Shadowing vs mut

fn main() {
    // Shadowing - เปลี่ยนชนิดได้
    let spaces = "   ";      // &str (string)
    let spaces = spaces.len(); // usize (number)
    println!("spaces = {}", spaces); // 3

    // mut - เปลี่ยนชนิดไม่ได้
    // let mut spaces = "   ";
    // spaces = spaces.len(); // ❌ Error! ชนิดต่างกัน
}

ลองทำดู! 🎯

1. ประกาศตัวแปร age และพยายามเปลี่ยนค่า ดูว่า error อะไร
2. เพิ่ม mut แล้วลองอีกครั้ง
3. ลอง shadowing: ประกาศ let x = 5; แล้วตามด้วย let x = "hello";

สรุป

👉 ต่อไป: ชนิดข้อมูล

ชนิดข้อมูล (Data Types)

Rust เป็นภาษา statically typed หมายความว่าต้องรู้ชนิดของตัวแปรทั้งหมดตอน compile

ประเภทของข้อมูล

Rust แบ่งชนิดข้อมูลเป็น 2 กลุ่มหลัก:

1. Scalar Types - ค่าเดี่ยว
2. Compound Types - ค่าหลายค่ารวมกัน

Scalar Types

1. Integer (จำนวนเต็ม)

fn main() {
    let a: i32 = 42;        // จำนวนเต็ม 32-bit
    let b: u8 = 255;        // จำนวนเต็มบวก 8-bit (0-255)
    let c = 1000;           // i32 (default)
    let d: isize = -500;    // ขึ้นกับ CPU (32 หรือ 64 bit)

    println!("a={}, b={}, c={}, d={}", a, b, c, d);
}

รูปแบบการเขียนตัวเลข

fn main() {
    let decimal = 98_222;      // Decimal (ใส่ _ ให้อ่านง่าย)
    let hex = 0xff;            // Hexadecimal
    let octal = 0o77;          // Octal
    let binary = 0b1111_0000;  // Binary
    let byte = b'A';           // Byte (u8 only)

    println!("{}, {}, {}, {}, {}", decimal, hex, octal, binary, byte);
    // 98222, 255, 63, 240, 65
}

2. Floating-Point (ทศนิยม)

fn main() {
    let x = 2.0;      // f64 (default, แม่นยำกว่า)
    let y: f32 = 3.0; // f32 (ใช้หน่วยความจำน้อยกว่า)

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

การคำนวณ

fn main() {
    let sum = 5 + 10;           // บวก
    let difference = 95.5 - 4.3; // ลบ
    let product = 4 * 30;        // คูณ
    let quotient = 56.7 / 32.2;  // หาร
    let remainder = 43 % 5;      // เศษ (modulo)

    println!("sum={}", sum);               // 15
    println!("difference={}", difference); // 91.2
    println!("product={}", product);       // 120
    println!("quotient={}", quotient);     // 1.76...
    println!("remainder={}", remainder);   // 3
}

3. Boolean (ค่าความจริง)

fn main() {
    let t = true;
    let f: bool = false;

    println!("t={}, f={}", t, f);

    // ใช้ในเงื่อนไข
    if t {
        println!("This is true!");
    }
}

4. Character (ตัวอักษร)

fn main() {
    let c = 'z';
    let z: char = 'ℤ';
    let heart_eyed_cat = '😻';
    let thai = 'ก';

    println!("{}, {}, {}, {}", c, z, heart_eyed_cat, thai);
}

หมายเหตุ: char ใน Rust ใช้ 4 bytes และรองรับ Unicode ทั้งหมด ใช้ single quote 'a' (ไม่ใช่ double quote "a")

Compound Types

1. Tuple (ทูเพิล)

Tuple รวมค่าหลายชนิดไว้ด้วยกัน มีขนาดคงที่

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    // Destructuring - แยกค่าออกมา
    let (x, y, z) = tup;
    println!("x={}, y={}, z={}", x, y, z);

    // เข้าถึงด้วย index
    let five_hundred = tup.0;
    let six_point_four = tup.1;
    let one = tup.2;

    println!("{}, {}, {}", five_hundred, six_point_four, one);
}

Unit Type

Tuple ว่าง () เรียกว่า unit ใช้แทน “ไม่มีค่า”

fn main() {
    let unit: () = ();
    println!("unit = {:?}", unit); // ()
}

2. Array (อาร์เรย์)

Array รวมค่าชนิดเดียวกันไว้ด้วยกัน มีขนาดคงที่

fn main() {
    // ประกาศ array
    let a = [1, 2, 3, 4, 5];

    // ระบุชนิดและขนาด
    let b: [i32; 5] = [1, 2, 3, 4, 5];

    // สร้าง array ที่มีค่าเหมือนกันทั้งหมด
    let c = [3; 5]; // [3, 3, 3, 3, 3]

    println!("a = {:?}", a);
    println!("b = {:?}", b);
    println!("c = {:?}", c);
}

การเข้าถึง Elements

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];  // 1
    let second = a[1]; // 2

    println!("first={}, second={}", first, second);
}

คำเตือน: ถ้าเข้าถึง index ที่ไม่มีอยู่ โปรแกรมจะ panic!

let a = [1, 2, 3];
let x = a[10]; // ❌ panic!

Type Annotation vs Type Inference

Rust สามารถเดาชนิดข้อมูลได้:

fn main() {
    // Type Inference - Rust เดาให้
    let x = 5;       // i32
    let y = 2.0;     // f64
    let z = true;    // bool

    // Type Annotation - ระบุเอง
    let a: i64 = 5;
    let b: f32 = 2.0;
    let c: bool = true;
}

ลองทำดู! 🎯

1. ประกาศตัวแปรแต่ละชนิดและ print ออกมา
2. สร้าง tuple ที่มี (ชื่อ, อายุ, ส่วนสูง) และแยกค่าออกมา
3. สร้าง array ของวันในสัปดาห์

สรุป

👉 ต่อไป: Constants & Shadowing

Constants & Shadowing

Constants (ค่าคงที่)

Constants คือค่าที่ไม่มีวันเปลี่ยนแปลง ใช้ const แทน let

const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159265359;
const APP_NAME: &str = "My Rust App";

fn main() {
    println!("Max points: {}", MAX_POINTS);
    println!("Pi: {}", PI);
    println!("App: {}", APP_NAME);
}

กฎของ Constants

1. ต้องระบุชนิด - ไม่สามารถให้ Rust เดาได้
2. ต้องเป็นค่าคงที่ - ไม่ได้มาจากการคำนวณตอน runtime
3. ใช้ได้ทุกที่ - รวมถึง global scope
4. SCREAMING_SNAKE_CASE - ใช้ตัวพิมพ์ใหญ่และ underscore

#![allow(unused)]
fn main() {
// ✅ ถูกต้อง
const MAX_SIZE: usize = 100;

// ❌ ไม่ได้ - ต้องระบุชนิด
// const MIN_SIZE = 10;

// ❌ ไม่ได้ - ค่าต้องคงที่
// const RANDOM: u32 = rand::random();
}

Static Variables

Static คล้าย constant แต่มี memory address คงที่

static LANGUAGE: &str = "Rust";
static mut COUNTER: u32 = 0; // ⚠️ ต้องใช้ unsafe

fn main() {
    println!("Language: {}", LANGUAGE);
}

คำเตือน: static mut ต้องใช้ใน unsafe block และควรหลีกเลี่ยงถ้าเป็นไปได้

const vs static vs let

Shadowing (ทบทวน)

Shadowing คือการประกาศตัวแปรชื่อเดิมซ้ำ:

fn main() {
    let x = 5;

    // Shadow ด้วยค่าใหม่
    let x = x + 1;

    {
        // Shadow ใน inner scope
        let x = x * 2;
        println!("Inner x: {}", x); // 12
    }

    println!("Outer x: {}", x); // 6
}

ประโยชน์ของ Shadowing

1. เปลี่ยนชนิดข้อมูลได้

fn main() {
    let spaces = "   ";        // &str
    let spaces = spaces.len(); // usize

    println!("spaces: {}", spaces); // 3
}

2. แปลงค่าโดยไม่ต้องสร้างชื่อใหม่

fn main() {
    let input = "42";
    let input: i32 = input.parse().unwrap();

    println!("input: {}", input); // 42
}

3. ใช้ใน Scope ที่ต้องการ

fn main() {
    let x = 1;

    {
        let x = 2;
        println!("x in block: {}", x); // 2
    }

    println!("x outside: {}", x); // 1
}

ตัวอย่างการใช้งานจริง

Configuration Constants

const MAX_CONNECTIONS: u32 = 100;
const TIMEOUT_SECONDS: u64 = 30;
const API_VERSION: &str = "v1.0";

fn main() {
    println!("Server config:");
    println!("  Max connections: {}", MAX_CONNECTIONS);
    println!("  Timeout: {} seconds", TIMEOUT_SECONDS);
    println!("  API version: {}", API_VERSION);
}

Mathematical Constants

const PI: f64 = 3.14159265358979323846;
const E: f64 = 2.71828182845904523536;

fn main() {
    let radius = 5.0;
    let area = PI * radius * radius;

    println!("Circle area: {:.2}", area); // 78.54
}

ลองทำดู! 🎯

1. สร้าง constants สำหรับแอพของคุณ (ชื่อแอพ, เวอร์ชัน)
2. ลอง shadow ตัวแปรเพื่อแปลง string เป็น number
3. สร้าง constants สำหรับค่า RGB ของสี

สรุปบทที่ 2

ในบทนี้คุณได้เรียนรู้:

• ✅ Immutable และ Mutable variables
• ✅ Scalar types: integers, floats, booleans, characters
• ✅ Compound types: tuples และ arrays
• ✅ Constants และ Shadowing

👉 ต่อไป: บทที่ 3: Functions

บทที่ 3: Functions - ฟังก์ชัน

ฟังก์ชัน เป็นหัวใจสำคัญของการเขียนโปรแกรม ช่วยให้เราจัดระเบียบและนำโค้ดกลับมาใช้ซ้ำได้

สิ่งที่จะได้เรียนรู้

ทำไมต้องใช้ฟังก์ชัน?

1. 🔄 Reusability - ใช้โค้ดซ้ำได้หลายครั้ง
2. 📦 Organization - จัดระเบียบโค้ดให้อ่านง่าย
3. 🐛 Debugging - หา bug ได้ง่ายกว่า
4. 🧪 Testing - ทดสอบแยกส่วนได้

เริ่มกันเลย!

👉 การสร้างฟังก์ชัน

การสร้างฟังก์ชัน

Syntax พื้นฐาน

fn function_name() {
    // body
}

📐 Function Anatomy

+-------------------------------------------------------------------+
|                  Function Anatomy in Rust                         |
+-------------------------------------------------------------------+
|                                                                   |
|   fn   calculate_sum  (  a: i32  ,  b: i32  )  ->  i32   {        |
|   ^         ^            ^--^       ^--^        ^--^      ^       |
|   |         |            |  |       |  |        |  |      |       |
|   |         |            |  type    |  type     |  return |       |
|   |         |            param      param       |  type   body    |
|   |         function name                       return            |
|   keyword                                                         |
|                                                                   |
|       a + b    <--- Expression (no semicolon) = return value      |
|   }                                                               |
|                                                                   |
+-------------------------------------------------------------------+
|   Tip: No semicolon after expression = return that value          |
+-------------------------------------------------------------------+

ตัวอย่าง

fn main() {
    println!("Hello from main!");

    another_function();
}

fn another_function() {
    println!("Hello from another function!");
}

ผลลัพธ์:

Hello from main!
Hello from another function!

Naming Conventions

ใน Rust ใช้ snake_case สำหรับชื่อฟังก์ชัน:

#![allow(unused)]
fn main() {
// ✅ ถูกต้อง - snake_case
fn calculate_area() {}
fn get_user_name() {}
fn process_data() {}

// ❌ ไม่ใช่ convention ของ Rust
fn CalculateArea() {} // PascalCase
fn calculateArea() {} // camelCase
}

ตำแหน่งของฟังก์ชัน

ฟังก์ชันสามารถประกาศไว้ที่ไหนก็ได้ในไฟล์:

fn main() {
    greet(); // เรียกฟังก์ชันที่อยู่ข้างล่าง ✅
}

fn greet() {
    println!("Hello!");
}

หมายเหตุ: ต่างจากบางภาษา (เช่น C) ที่ต้องประกาศฟังก์ชันก่อนเรียกใช้ Rust ไม่สนใจลำดับการประกาศ

ฟังก์ชันซ้อนกัน (ไม่ได้!)

ใน Rust ไม่สามารถประกาศฟังก์ชันซ้อนในฟังก์ชันได้:

// ❌ ไม่ได้
fn outer() {
    fn inner() { // Error!
        println!("Inner");
    }
    inner();
}

เคล็ดลับ: ถ้าต้องการ nested function ใช้ closure แทน:

fn main() {
    // ✅ ใช้ closure แทน nested function
    let greet = |name: &str| {
        println!("Hello, {}!", name);
    };

    greet("Rust");
    greet("World");

    // closure ที่จับตัวแปรจากภายนอก
    let multiplier = 3;
    let multiply = |x: i32| x * multiplier;

    println!("5 * 3 = {}", multiply(5)); // 15
}

ตัวอย่างจริง

fn main() {
    print_welcome_message();
    print_separator();
    print_goodbye_message();
}

fn print_welcome_message() {
    println!("╔═══════════════════════╗");
    println!("║   Welcome to Rust!    ║");
    println!("╚═══════════════════════╝");
}

fn print_separator() {
    println!("─────────────────────────");
}

fn print_goodbye_message() {
    println!("Thanks for learning Rust!");
}

ลองทำดู! 🎯

1. สร้างฟังก์ชัน print_name ที่พิมพ์ชื่อของคุณ
2. สร้างฟังก์ชัน print_age ที่พิมพ์อายุ
3. เรียกใช้ทั้งสองฟังก์ชันจาก main

สรุป

👉 ต่อไป: Parameters

Parameters (พารามิเตอร์)

Parameters คือค่าที่ส่งเข้าไปในฟังก์ชัน เพื่อให้ฟังก์ชันทำงานกับข้อมูลที่แตกต่างกันได้

Syntax

fn function_name(param1: Type1, param2: Type2) {
    // use param1 and param2
}

สำคัญ: ต้องระบุ ชนิดข้อมูล ของทุก parameter!

ตัวอย่างพื้นฐาน

fn main() {
    print_number(5);
    print_number(10);
}

fn print_number(x: i32) {
    println!("The number is: {}", x);
}

ผลลัพธ์:

The number is: 5
The number is: 10

หลาย Parameters

fn main() {
    print_labeled_measurement(5, 'h');
    greet("Alice", 25);
}

fn print_labeled_measurement(value: i32, unit: char) {
    println!("The measurement is: {}{}", value, unit);
}

fn greet(name: &str, age: u32) {
    println!("Hello, {}! You are {} years old.", name, age);
}

ผลลัพธ์:

The measurement is: 5h
Hello, Alice! You are 25 years old.

Arguments vs Parameters

fn add(x: i32, y: i32) { // x, y เป็น parameters
    println!("{}", x + y);
}

fn main() {
    add(5, 3); // 5, 3 เป็น arguments
}

ชนิดข้อมูลที่ใช้บ่อย

fn main() {
    integers(10, -5);
    floats(3.14, 2.5);
    with_string("Hello");
    with_boolean(true);
}

fn integers(a: i32, b: i32) {
    println!("Integers: {} + {} = {}", a, b, a + b);
}

fn floats(a: f64, b: f64) {
    println!("Floats: {} * {} = {}", a, b, a * b);
}

fn with_string(s: &str) {
    println!("String: {}", s);
}

fn with_boolean(flag: bool) {
    println!("Boolean: {}", flag);
}

ตัวอย่างจริง: คำนวณพื้นที่

fn main() {
    let width = 10;
    let height = 5;

    calculate_area(width, height);
}

fn calculate_area(width: u32, height: u32) {
    let area = width * height;
    println!("Width: {}", width);
    println!("Height: {}", height);
    println!("Area: {}", area);
}

ลองทำดู! 🎯

1. สร้างฟังก์ชัน introduce(name: &str, age: u32) ที่พิมพ์แนะนำตัว
2. สร้างฟังก์ชัน calculate_bmi(weight: f64, height: f64) ที่คำนวณ BMI
3. สร้างฟังก์ชัน print_grade(score: u32) ที่พิมพ์เกรด

สรุป

👉 ต่อไป: Return Values

Return Values (ค่าที่ส่งกลับ)

ฟังก์ชันสามารถ ส่งค่ากลับ ให้ผู้เรียกใช้ได้

Syntax

fn function_name() -> ReturnType {
    // return value
}

• ใช้ -> ระบุชนิดค่าที่ส่งกลับ
• ค่าสุดท้ายใน function body จะถูกส่งกลับ (ไม่ต้องใส่ ;)

ตัวอย่างพื้นฐาน

fn main() {
    let x = five();
    println!("x = {}", x); // 5
}

fn five() -> i32 {
    5 // ไม่มี ; = ส่งค่านี้กลับ
}

Expressions vs Statements

ใน Rust มีแนวคิดสำคัญ:

fn main() {
    // Statement - ไม่มีค่า
    let x = 5; // let ... เป็น statement

    // Expression - มีค่า
    let y = {
        let a = 3;
        a + 1   // ไม่มี ; = expression ที่ return ค่า
    };

    println!("y = {}", y); // 4
}

สำคัญมาก: ถ้าใส่ ; ท้าย จะกลายเป็น statement และไม่ return ค่า!

fn main() {
    let y = {
        let a = 3;
        a + 1; // มี ; = statement = return () (unit)
    };

    // y มีค่าเป็น () ไม่ใช่ 4!
}

ตัวอย่างฟังก์ชันที่ return ค่า

fn main() {
    let sum = add(5, 3);
    println!("5 + 3 = {}", sum); // 8

    let product = multiply(4, 7);
    println!("4 * 7 = {}", product); // 28

    let result = add(multiply(2, 3), 4);
    println!("(2 * 3) + 4 = {}", result); // 10
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

ใช้ return keyword

สามารถใช้ return เพื่อ return ก่อนจบฟังก์ชันได้:

fn main() {
    println!("{}", absolute(-5)); // 5
    println!("{}", absolute(3));  // 3
}

fn absolute(x: i32) -> i32 {
    if x < 0 {
        return -x; // return ก่อนกำหนด
    }
    x // implicit return
}

แนะนำ: ใช้ implicit return (ไม่ใส่ return) เมื่อเป็นไปได้ ใช้ return เมื่อต้อง return ก่อนจบฟังก์ชัน

ฟังก์ชันที่ไม่ return ค่า

ถ้าไม่ระบุ -> ฟังก์ชันจะ return () (unit):

fn main() {
    let result = print_hello();
    println!("result = {:?}", result); // ()
}

fn print_hello() {
    println!("Hello!");
    // implicitly returns ()
}

เทียบเท่ากับ:

#![allow(unused)]
fn main() {
fn print_hello() -> () {
    println!("Hello!");
}
}

ตัวอย่างจริง

fn main() {
    let radius = 5.0;
    let area = circle_area(radius);
    let circumference = circle_circumference(radius);

    println!("Circle with radius {}:", radius);
    println!("  Area: {:.2}", area);
    println!("  Circumference: {:.2}", circumference);
}

fn circle_area(radius: f64) -> f64 {
    3.14159 * radius * radius
}

fn circle_circumference(radius: f64) -> f64 {
    2.0 * 3.14159 * radius
}

ผลลัพธ์:

Circle with radius 5:
  Area: 78.54
  Circumference: 31.42

ลองทำดู! 🎯

1. สร้างฟังก์ชัน square(x: i32) -> i32 ที่ return ค่ายกกำลังสอง
2. สร้างฟังก์ชัน max(a: i32, b: i32) -> i32 ที่ return ค่าที่มากกว่า
3. สร้างฟังก์ชัน is_even(n: i32) -> bool ที่ return true ถ้าเป็นเลขคู่

สรุปบทที่ 3

👉 ต่อไป: บทที่ 4: Control Flow

บทที่ 4: Control Flow - การควบคุมโปรแกรม

Control Flow ควบคุมลำดับการทำงานของโปรแกรม ให้ทำสิ่งต่างๆ ตามเงื่อนไข หรือทำซ้ำ

สิ่งที่จะได้เรียนรู้

ทำไมต้องเรียน?

โปรแกรมที่มีประโยชน์ต้อง:

• 🔀 ตัดสินใจ - ทำสิ่งต่างกันตามสถานการณ์
• 🔁 ทำซ้ำ - ประมวลผลข้อมูลจำนวนมาก
• ⚡ แยกกรณี - จัดการหลายกรณีพร้อมกัน

เริ่มกันเลย!

👉 if/else

if/else - เงื่อนไข

if ใช้ตัดสินใจว่าจะทำโค้ดส่วนไหน ตามเงื่อนไข

🔀 Control Flow Visualization

+-------------------------------------------------------------------+
|                    if/else Control Flow                           |
+-------------------------------------------------------------------+
|                                                                   |
|                      +-----------+                                |
|                      | condition |                                |
|                      +-----+-----+                                |
|                            |                                      |
|             +--------------+--------------+                       |
|             |              |              |                       |
|             v              v              v                       |
|        +--------+    +----------+    +--------+                   |
|        |  true  |    | else if  |    | false  |                   |
|        | block  |    | (option) |    | block  |                   |
|        +---+----+    +----+-----+    +---+----+                   |
|            |              |              |                        |
|            +--------------+--------------+                        |
|                           |                                       |
|                           v                                       |
|                     continue...                                   |
|                                                                   |
+-------------------------------------------------------------------+
|   Tip: In Rust, no () around condition: if x > 5 (not if (x>5))   |
+-------------------------------------------------------------------+

Syntax พื้นฐาน

if condition {
    // ทำเมื่อ condition เป็น true
}

ตัวอย่าง

fn main() {
    let number = 7;

    if number > 5 {
        println!("{} is greater than 5", number);
    }
}

if-else

fn main() {
    let number = 3;

    if number > 5 {
        println!("Greater than 5");
    } else {
        println!("Less than or equal to 5");
    }
}

else if

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("Divisible by 4");
    } else if number % 3 == 0 {
        println!("Divisible by 3");
    } else if number % 2 == 0 {
        println!("Divisible by 2");
    } else {
        println!("Not divisible by 4, 3, or 2");
    }
}

ผลลัพธ์:

Divisible by 3

หมายเหตุ: Rust จะหยุดเมื่อเจอเงื่อนไขแรกที่ true ดังนั้น 6 หาร 2 ลงตัวด้วย แต่ไม่ถูกพิมพ์

Condition ต้องเป็น bool

ใน Rust condition ต้องเป็น bool:

fn main() {
    let number = 3;

    // ❌ Error! number ไม่ใช่ bool
    // if number {
    //     println!("number is not zero");
    // }

    // ✅ ถูกต้อง
    if number != 0 {
        println!("number is not zero");
    }
}

if ใน let (Ternary-like)

เพราะ if เป็น expression สามารถใส่ใน let ได้:

fn main() {
    let condition = true;

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

    println!("number = {}", number); // 5
}

สำคัญ: ทุก branch ต้อง return ชนิดเดียวกัน

fn main() {
    let condition = true;

    // ❌ Error! ชนิดไม่ตรงกัน
    // let number = if condition { 5 } else { "six" };

    // ✅ ต้องเป็นชนิดเดียวกัน
    let number = if condition { 5 } else { 6 };
}

ตัวอย่างจริง: ตรวจสอบอายุ

fn main() {
    let age = 25;

    let category = if age < 13 {
        "Child"
    } else if age < 20 {
        "Teenager"
    } else if age < 60 {
        "Adult"
    } else {
        "Senior"
    };

    println!("Age {} is {}", age, category);
}

ตัวอย่างจริง: ตรวจสอบเกรด

fn main() {
    let score = 85;

    let grade = if score >= 80 {
        'A'
    } else if score >= 70 {
        'B'
    } else if score >= 60 {
        'C'
    } else if score >= 50 {
        'D'
    } else {
        'F'
    };

    println!("Score {} = Grade {}", score, grade);
}

Nested if

fn main() {
    let number = 15;

    if number > 0 {
        if number % 2 == 0 {
            println!("{} is positive and even", number);
        } else {
            println!("{} is positive and odd", number);
        }
    } else {
        println!("{} is not positive", number);
    }
}

ลองทำดู! 🎯

1. เขียนโปรแกรมตรวจสอบว่าตัวเลขเป็นบวก ลบ หรือศูนย์
2. เขียนฟังก์ชัน max(a, b) -> i32 ที่ return ค่าที่มากกว่า
3. เขียนโปรแกรมตรวจสอบปีอธิกสุรทิน

สรุป

👉 ต่อไป: Loops

Loops - การวนซ้ำ

Rust มี 3 ประเภทของ loop:

loop - วนไม่รู้จบ

fn main() {
    let mut count = 0;

    loop {
        count += 1;
        println!("Count: {}", count);

        if count >= 3 {
            break; // ออกจาก loop
        }
    }
}

ผลลัพธ์:

Count: 1
Count: 2
Count: 3

Return ค่าจาก loop

loop สามารถ return ค่าผ่าน break:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // return 20
        }
    };

    println!("Result: {}", result); // 20
}

while - วนตามเงื่อนไข

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("LIFTOFF!");
}

ผลลัพธ์:

3!
2!
1!
LIFTOFF!

for - วนตาม collection

for เป็น loop ที่ใช้บ่อยที่สุด:

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("Value: {}", element);
    }
}

Range

fn main() {
    // 1 ถึง 4 (ไม่รวม 5)
    for number in 1..5 {
        println!("{}", number);
    }
    // 1, 2, 3, 4

    println!("---");

    // 1 ถึง 5 (รวม 5)
    for number in 1..=5 {
        println!("{}", number);
    }
    // 1, 2, 3, 4, 5
}

Reverse

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!");
}

ผลลัพธ์:

3!
2!
1!
LIFTOFF!

continue - ข้าม iteration

fn main() {
    for number in 1..=10 {
        if number % 2 == 0 {
            continue; // ข้ามเลขคู่
        }
        println!("{}", number);
    }
}

ผลลัพธ์:

1
3
5
7
9

Loop Labels

ใช้ label เพื่อ break/continue loop นอก:

fn main() {
    let mut count = 0;

    'outer: loop {
        println!("count = {}", count);
        let mut remaining = 10;

        loop {
            println!("  remaining = {}", remaining);
            if remaining == 9 {
                break; // break inner loop
            }
            if count == 2 {
                break 'outer; // break outer loop
            }
            remaining -= 1;
        }

        count += 1;
    }

    println!("End count = {}", count);
}

เปรียบเทียบ Loops

เมื่อไหร่ใช้อะไร?

fn main() {
    // ใช้ for เมื่อรู้จำนวนรอบ หรือวน collection
    for i in 0..5 {
        println!("for: {}", i);
    }

    // ใช้ while เมื่อขึ้นอยู่กับเงื่อนไข
    let mut x = 5;
    while x > 0 {
        println!("while: {}", x);
        x -= 1;
    }

    // ใช้ loop เมื่อต้องการ return ค่า หรือ retry logic
    let result = loop {
        // some logic
        break 42;
    };
    println!("loop result: {}", result);
}

ตัวอย่างจริง: FizzBuzz

fn main() {
    for n in 1..=15 {
        if n % 15 == 0 {
            println!("FizzBuzz");
        } else if n % 3 == 0 {
            println!("Fizz");
        } else if n % 5 == 0 {
            println!("Buzz");
        } else {
            println!("{}", n);
        }
    }
}

ตัวอย่างจริง: หาผลรวม

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    let mut sum = 0;

    for n in numbers {
        sum += n;
    }

    println!("Sum: {}", sum); // 15
}

ลองทำดู! 🎯

1. เขียน loop พิมพ์ตาราง 9
2. เขียนโปรแกรมหาตัวเลขเฉพาะตั้งแต่ 1-50
3. เขียน nested loop พิมพ์รูปสามเหลี่ยม *

สรุป

👉 ต่อไป: Match เบื้องต้น

Match เบื้องต้น

match เป็น control flow ที่ทรงพลังใน Rust ใช้เปรียบเทียบค่ากับ patterns

Syntax พื้นฐาน

match value {
    pattern1 => expression1,
    pattern2 => expression2,
    _ => default_expression,
}

ตัวอย่างพื้นฐาน

fn main() {
    let number = 3;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Something else"),
    }
}

ผลลัพธ์:

Three

_ (Underscore) - Catch-all

_ จับทุกกรณีที่ไม่ตรงกับ pattern อื่น:

fn main() {
    let number = 7;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other: {}", number),
    }
}

สำคัญ: match ต้องครอบคลุมทุกกรณี (exhaustive) ถ้าไม่ครบ จะ compile error

match กับ Return ค่า

match เป็น expression สามารถ return ค่าได้:

fn main() {
    let number = 2;

    let text = match number {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "other",
    };

    println!("{}", text); // two
}

Match หลายค่า

ใช้ | เพื่อ match หลายค่าในครั้งเดียว:

fn main() {
    let number = 2;

    match number {
        1 | 2 | 3 => println!("One, two, or three"),
        4 | 5 | 6 => println!("Four, five, or six"),
        _ => println!("Something else"),
    }
}

Match Range

ใช้ ..= เพื่อ match ช่วงค่า:

fn main() {
    let number = 5;

    match number {
        1..=5 => println!("One through five"),
        6..=10 => println!("Six through ten"),
        _ => println!("Something else"),
    }
}

Match กับ char

fn main() {
    let letter = 'c';

    match letter {
        'a'..='j' => println!("Early letter"),
        'k'..='z' => println!("Late letter"),
        _ => println!("Not a lowercase letter"),
    }
}

match vs if-else

fn main() {
    let number = 3;

    // match - ชัดเจนกว่า
    let result = match number {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "other",
    };

    // if-else - ยาวกว่า
    let result2 = if number == 1 {
        "one"
    } else if number == 2 {
        "two"
    } else if number == 3 {
        "three"
    } else {
        "other"
    };
}

ตัวอย่างจริง: วันในสัปดาห์

fn main() {
    let day = 3;

    let day_name = match day {
        1 => "Monday",
        2 => "Tuesday",
        3 => "Wednesday",
        4 => "Thursday",
        5 => "Friday",
        6 | 7 => "Weekend!",
        _ => "Invalid day",
    };

    println!("Day {} is {}", day, day_name);
}

ตัวอย่างจริง: คะแนนเป็นเกรด

fn main() {
    let score = 85;

    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        60..=69 => 'D',
        0..=59 => 'F',
        _ => '?', // คะแนนไม่ถูกต้อง
    };

    println!("Score {} = Grade {}", score, grade);
}

Multiple Lines ใน Arm

ใช้ { } เมื่อต้องการหลายบรรทัด:

fn main() {
    let number = 2;

    match number {
        1 => {
            println!("Number is one");
            println!("It's the first number");
        }
        2 => {
            println!("Number is two");
            println!("It's the second number");
        }
        _ => println!("Something else"),
    }
}

ลองทำดู! 🎯

1. เขียน match แปลงเดือน (1-12) เป็นชื่อเดือน
2. เขียน match จัดกลุ่มอายุ (เด็ก, วัยรุ่น, ผู้ใหญ่, ผู้สูงอายุ)
3. เขียน match สำหรับ rock-paper-scissors

สรุปบทที่ 4

👉 ต่อไป: บทที่ 5: Ownership

บทที่ 5: Ownership - ระบบ Ownership ⭐

Ownership เป็นหัวใจสำคัญของ Rust และเป็นสิ่งที่ทำให้ Rust แตกต่างจากภาษาอื่น!

ทำไมบทนี้สำคัญมาก?

นี่คือบทที่สำคัญที่สุดในหนังสือเล่มนี้!

Ownership คือสิ่งที่ทำให้ Rust:

• ปลอดภัยจาก memory bugs
• ไม่ต้องใช้ Garbage Collector
• มีประสิทธิภาพสูง

ถ้าคุณเข้าใจ Ownership คุณจะเข้าใจ Rust 🦀

สิ่งที่จะได้เรียนรู้

ปัญหาที่ Ownership แก้

ในภาษาอื่น อาจเจอปัญหาเหล่านี้:

1. Use after free - ใช้ memory ที่ถูก free ไปแล้ว
2. Double free - free memory ซ้ำ
3. Dangling pointers - pointer ชี้ไปที่ที่ไม่มีอยู่
4. Memory leaks - ลืม free memory

Rust ป้องกันปัญหาทั้งหมดนี้ตอน compile time!

เริ่มกันเลย!

👉 Ownership คืออะไร

Ownership คืออะไร

กฎ 3 ข้อของ Ownership

จำกฎ 3 ข้อนี้ให้ขึ้นใจ:

1. ทุกค่ามีเจ้าของ (owner) หนึ่งเดียว
2. ในเวลาใดก็ตาม ค่าหนึ่งมีได้แค่เจ้าของเดียว
3. เมื่อเจ้าของออกจาก scope ค่าจะถูก drop (ลบ)

⚠️ คำเตือน: ข้อผิดพลาดที่พบบ่อย

• ❌ ใช้ตัวแปรหลัง move
• ❌ ส่ง ownership เข้า function แล้วพยายามใช้ต่อ
• ❌ สร้าง multiple mutable references
• ✅ ใช้ .clone() เมื่อต้องการ copy จริงๆ
• ✅ ใช้ references (&) แทน move เมื่อไม่จำเป็นต้องโอน ownership

🔄 Ownership Flow Diagram

+-------------------------------------------------------------------+
|                  Ownership Flow Visualization                     |
+-------------------------------------------------------------------+
|                                                                   |
|   let s1 = String::from("hello");                                 |
|       |                                                           |
|       v                                                           |
|   +-------+                                                       |
|   |  s1   | <-- owner of "hello"                                  |
|   +---+---+                                                       |
|       |                                                           |
|       |  let s2 = s1;  (MOVE)                                     |
|       |                                                           |
|       v                                                           |
|   +-------+     +-------+                                         |
|   |  s1   | --> |  s2   | <-- new owner                           |
|   | DEAD  |     |  OK   |                                         |
|   +-------+     +-------+                                         |
|   (invalid)     (valid)                                           |
|                                                                   |
+-------------------------------------------------------------------+
|  Alternatives:                                                    |
|  1. CLONE: let s2 = s1.clone();  -> s1 OK, s2 OK (both copies)    |
|  2. BORROW: let s2 = &s1;        -> s1 OK, s2 OK (temporary ref)  |
+-------------------------------------------------------------------+

ตัวอย่างพื้นฐาน

fn main() {
    {
        let s = String::from("hello"); // s เกิดขึ้น เป็น owner ของ "hello"

        println!("{}", s); // ใช้ s ได้

    } // s ออกจาก scope -> memory ถูก free อัตโนมัติ

    // println!("{}", s); // ❌ Error! s ไม่มีแล้ว
}

Stack vs Heap

เพื่อเข้าใจ Ownership ต้องเข้าใจ Stack และ Heap ก่อน:

Stack

• เก็บข้อมูลขนาดคงที่
• เร็วมาก
• LIFO (Last In, First Out)
• เช่น: i32, f64, bool, char

Heap

• เก็บข้อมูลขนาดไม่คงที่
• ช้ากว่า Stack
• ต้อง allocate และ deallocate
• เช่น: String, Vec<T>

+-----------------+
|     Stack       |
+-----------------+
| ptr  ----------+       +---------------+
| len = 5        |       |     Heap      |
| capacity = 5   |       +---------------+
+----------------+------>| h e l l o     |
                         |               |
                         +---------------+

Copy Types vs Move Types

Copy Types (อยู่บน Stack)

ข้อมูลขนาดเล็กถูก copy อัตโนมัติ:

fn main() {
    let x = 5;
    let y = x; // copy ค่า

    println!("x = {}, y = {}", x, y); // ✅ ทั้งสองใช้ได้
}

Move Types (อยู่บน Heap)

ข้อมูลบน Heap ถูก move:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 ถูก MOVE ไป s2

    // println!("{}", s1); // ❌ Error! s1 ถูก move ไปแล้ว
    println!("{}", s2); // ✅ OK
}

ทำไมต้อง Move?

ถ้า Rust copy ข้อมูลบน Heap แทนที่จะ move:

        +-------------+
s1 ---->|   hello     |<---- s2 (if copy)
        +-------------+

When s1 and s2 go out of scope
-> Both try to free the same memory
-> DOUBLE FREE!

Rust ป้องกันโดยทำให้ s1 ใช้ไม่ได้หลัง move

Ownership และ Functions

ส่งค่าเข้า function = Move

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

    takes_ownership(s); // s ถูก move เข้า function

    // println!("{}", s); // ❌ Error! s ถูก move ไปแล้ว
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string ถูก drop ที่นี่

Return = ย้าย ownership กลับ

fn main() {
    let s1 = gives_ownership(); // s1 ได้รับ ownership

    println!("{}", s1); // ✅ OK
}

fn gives_ownership() -> String {
    let s = String::from("hello");
    s // return และ move ownership
}

ตัวอย่าง: ส่งและรับกลับ

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();
    (s, length) // return tuple
}

ปัญหา: ต้อง return ค่ากลับมาถ้าต้องการใช้ต่อ ยุ่งยากมาก!

ทางออก: ใช้ References (บทถัดไป)

Scope และ Drop

fn main() {
    let outer = String::from("outer");

    {
        let inner = String::from("inner");
        println!("{}", inner); // ✅ OK
    } // inner ถูก drop ที่นี่

    // println!("{}", inner); // ❌ inner ไม่มีแล้ว

    println!("{}", outer); // ✅ OK
} // outer ถูก drop ที่นี่

ลองทำดู! 🎯

1. ลองเขียนโค้ดที่ move String และดู error
2. แก้ไขโดยใช้ .clone()
3. ลองส่ง String เข้า function และดูว่าเกิดอะไร

🧠 Advanced: Ownership Edge Cases

Case 1: Partial Move

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
    };
    
    let name = person.name;  // move name ออกจาก struct
    // println!("{}", person.name);  // ❌ Error! name ถูก move แล้ว
    println!("{}", person.age);      // ✅ OK! age ยังอยู่ (Copy type)
}

Case 2: Reference ใน Struct

// ❌ ไม่ได้! struct เก็บ reference ต้องมี lifetime
struct BadStruct {
    data: &str,  // Error: missing lifetime specifier
}

// ✅ ถูกต้อง
struct GoodStruct<'a> {
    data: &'a str,
}

Case 3: เมื่อใดใช้ Clone vs Reference

📝 ทดสอบความเข้าใจ

สรุป

👉 ต่อไป: Move & Clone

Move & Clone

Move (การย้าย)

เมื่อ assign ตัวแปร heap type ให้ตัวแปรอื่น ค่าจะถูก move:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // MOVE!

    // s1 invalidated แล้ว
    // println!("{}", s1); // ❌ Error: borrow of moved value

    println!("{}", s2); // ✅ OK
}

แผนภาพ Move

ก่อน Move:
s1 ──────► "hello" (Heap)

หลัง Move:
s1 ──╳──► (invalidated)
s2 ──────► "hello" (Heap)

Clone (การคัดลอก Deep Copy)

ถ้าต้องการ copy ข้อมูลจริงๆ ใช้ .clone():

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // CLONE - deep copy

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

แผนภาพ Clone

หลัง Clone:
s1 ──────► "hello" (Heap memory 1)
s2 ──────► "hello" (Heap memory 2)

คำเตือน: .clone() อาจแพงในแง่ performance เพราะต้อง copy ทุก byte

Copy vs Clone

Copy (อัตโนมัติสำหรับ Stack types)

fn main() {
    let x = 5;
    let y = x; // COPY (อัตโนมัติ)

    println!("x = {}, y = {}", x, y); // ✅ ทั้งสองใช้ได้
}

เมื่อไหร่ใช้ Clone?

1. ต้องการให้ทั้งสองตัวแปรใช้ข้อมูลเดียวกัน

fn main() {
    let original = String::from("hello");
    let backup = original.clone();

    // ใช้ทั้งสองได้
    println!("original: {}", original);
    println!("backup: {}", backup);
}

2. ส่งค่าเข้า function แต่ยังต้องการใช้

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

    print_string(s.clone()); // ส่ง clone ไป

    println!("Still have: {}", s); // ✅ s ยังใช้ได้
}

fn print_string(s: String) {
    println!("{}", s);
}

ดีกว่า: ใช้ References แทน clone (บทถัดไป)

Clone กับ Collections

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = v1.clone();

    println!("v1: {:?}", v1);
    println!("v2: {:?}", v2);

    // แก้ไข v2 ไม่กระทบ v1
    // (ถ้าทำได้ ต้องเป็น mut)
}

Copy Trait

Types ที่มี Copy trait จะถูก copy อัตโนมัติ:

fn main() {
    // ทั้งหมดนี้มี Copy
    let a: i32 = 5;
    let b = a; // copy

    let c: f64 = 3.14;
    let d = c; // copy

    let e: bool = true;
    let f = e; // copy

    let g: char = 'A';
    let h = g; // copy

    // Tuple ที่มี Copy types
    let tuple1 = (1, 2, 3);
    let tuple2 = tuple1; // copy

    // ใช้ได้ทั้งหมด
    println!("{} {} {} {} {} {}", a, c, e, g, tuple1.0, tuple2.0);
}

สรุป: Move vs Clone vs Copy

fn main() {
    // Copy - Stack types (อัตโนมัติ)
    let x = 5;
    let y = x;
    println!("x={}, y={}", x, y); // ✅

    // Move - Heap types (default)
    let s1 = String::from("hello");
    let s2 = s1;
    // println!("{}", s1); // ❌ moved
    println!("{}", s2); // ✅

    // Clone - Explicit deep copy
    let s3 = String::from("world");
    let s4 = s3.clone();
    println!("s3={}, s4={}", s3, s4); // ✅
}

ลองทำดู! 🎯

1. สร้าง 2 Strings และลอง move ระหว่างกัน
2. ใช้ .clone() เพื่อให้ทั้งสองใช้ได้
3. ลองกับ Vec และ HashMaps

สรุป

👉 ต่อไป: References & Borrowing

References & Borrowing

References ช่วยให้เรา “ยืม” ค่า โดยไม่ย้าย ownership

ปัญหา: ต้อง Return ค่ากลับ

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

    let (s2, len) = calculate_length(s1);

    println!("Length of '{}' is {}", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let len = s.len();
    (s, len) // ต้อง return s กลับ 😩
}

ทางออก: ใช้ Reference

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

    let len = calculate_length(&s1); // ส่ง reference

    println!("Length of '{}' is {}", s1, len); // s1 ยังใช้ได้!
}

fn calculate_length(s: &String) -> usize { // รับ reference
    s.len()
}

Reference คืออะไร?

Reference คือ pointer ที่ชี้ไปยังค่า โดยไม่เป็นเจ้าของ:

s1 ──────► "hello" (Heap)
           ▲
           │
&s1 ───────┘ (Reference ชี้ไปที่ s1)

• &s1 สร้าง reference ไปยัง s1
• &String คือ type ของ reference

กฎของ References (สำคัญมาก!)

กฎ 1: ในเวลาใดก็ตาม มีหนึ่งในสิ่งนี้ได้:

• หนึ่ง mutable reference (&mut T)
• กี่อันก็ได้ immutable references (&T)

กฎ 2: References ต้อง valid เสมอ (ไม่ dangling)

Immutable References (&T)

สามารถมีหลาย immutable references พร้อมกันได้:

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

    let r1 = &s; // ✅
    let r2 = &s; // ✅
    let r3 = &s; // ✅

    println!("{}, {}, {}", r1, r2, r3);
}

แต่ไม่สามารถแก้ไขได้

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

    let r = &s;

    // r.push_str(" world"); // ❌ Error! cannot borrow as mutable
}

Mutable References (&mut T)

ใช้ &mut เมื่อต้องการแก้ไข:

fn main() {
    let mut s = String::from("hello"); // ต้อง mut

    change(&mut s); // ส่ง mutable reference

    println!("{}", s); // "hello world"
}

fn change(s: &mut String) {
    s.push_str(" world");
}

มีได้แค่หนึ่ง mutable reference

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

    let r1 = &mut s;
    // let r2 = &mut s; // ❌ Error! cannot borrow as mutable more than once

    println!("{}", r1);
}

ห้ามผสม Mutable และ Immutable

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

    let r1 = &s;     // immutable borrow
    let r2 = &s;     // immutable borrow
    // let r3 = &mut s; // ❌ Error! cannot borrow as mutable

    println!("{} and {}", r1, r2);
}

แต่ทำได้ถ้า scope ไม่ทับกัน

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

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // r1 และ r2 ไม่ถูกใช้อีกหลังจากนี้

    let r3 = &mut s; // ✅ OK เพราะ r1, r2 จบแล้ว
    println!("{}", r3);
}

Dangling References

Rust ป้องกัน dangling references:

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

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

    &s // reference ไปยัง s
} // s ถูก drop ที่นี่ -> reference จะ invalid!

แก้ไขโดย return ค่าแทน

fn main() {
    let s = no_dangle();
    println!("{}", s);
}

fn no_dangle() -> String { // ✅ Return String แทน
    let s = String::from("hello");
    s // move ownership ออกไป
}

สรุป: Reference Types

ตัวอย่างจริง

fn main() {
    let mut message = String::from("Hello");

    // อ่านค่า
    print_length(&message);

    // แก้ไขค่า
    add_world(&mut message);

    println!("Final: {}", message);
}

fn print_length(s: &String) {
    println!("Length: {}", s.len());
}

fn add_world(s: &mut String) {
    s.push_str(", World!");
}

ลองทำดู! 🎯

1. เขียน function ที่รับ &String และ return ความยาว
2. เขียน function ที่รับ &mut Vec<i32> และ push ค่าเข้าไป
3. ลองสร้าง dangling reference และดู error

สรุป

👉 ต่อไป: Slices

Slices

Slices ให้เราอ้างอิง ส่วนหนึ่ง ของ collection โดยไม่ต้อง copy

String Slices

fn main() {
    let s = String::from("Hello World");

    let hello = &s[0..5];  // "Hello"
    let world = &s[6..11]; // "World"

    println!("{} {}", hello, world);
}

Syntax

&s[start..end]  // start ถึง end-1
&s[start..]     // start ถึงท้าย
&s[..end]       // ต้นถึง end-1
&s[..]          // ทั้งหมด

ตัวอย่าง

fn main() {
    let s = String::from("Hello World");

    let slice1 = &s[0..5];   // "Hello"
    let slice2 = &s[..5];    // "Hello" (เหมือนกัน)

    let slice3 = &s[6..11];  // "World"
    let slice4 = &s[6..];    // "World" (เหมือนกัน)

    let slice5 = &s[0..11];  // "Hello World"
    let slice6 = &s[..];     // "Hello World" (เหมือนกัน)
}

&str Type

&str คือ string slice - reference ไปยังส่วนหนึ่งของ String:

fn main() {
    let s = String::from("Hello World");

    let word: &str = &s[0..5];

    println!("{}", word);
}

String Literals = &str

fn main() {
    let s: &str = "Hello World"; // string literal

    // s เป็น &str ที่ชี้ไปยังข้อมูลใน binary
}

ใช้ Slices กับ Functions

fn main() {
    let sentence = String::from("Hello World");

    let word = first_word(&sentence);

    println!("First word: {}", word);
}

fn first_word(s: &str) -> &str { // รับ &str แทน &String
    let bytes = s.as_bytes();

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

    &s[..]
}

เคล็ดลับ: ใช้ &str เป็น parameter ดีกว่า &String เพราะรับได้ทั้ง String และ &str

fn main() {
    let my_string = String::from("Hello World");

    // ทำงานกับ slice ของ String
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    let word = first_word(&my_string); // deref coercion

    // ทำงานกับ string literal (&str)
    let my_literal = "Hello World";
    let word = first_word(&my_literal[0..6]);
    let word = first_word(my_literal); // ส่งตรงได้เลย
}

fn first_word(s: &str) -> &str {
    // ...
    s
}

Slices ช่วยป้องกัน Bug

โดยไม่มี slices:

fn first_word_index(s: &String) -> usize {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }
    s.len()
}

fn main() {
    let mut s = String::from("Hello World");

    let word_end = first_word_index(&s); // 5

    s.clear(); // s ว่างเปล่าแล้ว

    // word_end ยังเป็น 5 อยู่ แต่ไม่มีความหมายแล้ว!
    // Bug! 🐛
}

ใช้ slices:

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let mut s = String::from("Hello World");

    let word = first_word(&s);

    // s.clear(); // ❌ Error! cannot borrow as mutable

    println!("{}", word);
}

Rust ป้องกันไม่ให้แก้ไข s เพราะมี immutable borrow อยู่!

Array Slices

ใช้ได้กับ arrays ด้วย:

fn main() {
    let a = [1, 2, 3, 4, 5];

    let slice: &[i32] = &a[1..3];

    println!("{:?}", slice); // [2, 3]
}

ตัวอย่างจริง

fn main() {
    let text = "The quick brown fox jumps over the lazy dog";

    let words: Vec<&str> = text.split(' ').collect();

    for word in words {
        println!("{}", word);
    }

    // หรือใช้ slice โดยตรง
    let first_three = &text[0..15]; // "The quick brown"
    println!("First part: {}", first_three);
}

ลองทำดู! 🎯

1. เขียน function ที่ return คำสุดท้ายของ string
2. เขียน function ที่ return middle element ของ array
3. ลองใช้ slice กับ Vec

สรุปบทที่ 5

🎉 ยินดีด้วย! คุณผ่านบทที่ยากที่สุดแล้ว!

👉 ต่อไป: บทที่ 6: Structs

บทที่ 6: Structs - โครงสร้างข้อมูล

Struct ช่วยให้เราสร้าง custom data type ที่รวมข้อมูลหลายชิ้นไว้ด้วยกัน

สิ่งที่จะได้เรียนรู้

ทำไมต้องใช้ Struct?

แทนที่จะเขียนแบบนี้:

#![allow(unused)]
fn main() {
let user_name = "Alice";
let user_email = "alice@example.com";
let user_age = 25;
}

ใช้ Struct รวมข้อมูลที่เกี่ยวข้องกัน:

#![allow(unused)]
fn main() {
struct User {
    name: String,
    email: String,
    age: u32,
}
}

เริ่มกันเลย!

👉 การสร้าง Struct

การสร้าง Struct

นิยาม Struct

#![allow(unused)]
fn main() {
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
}

• ใช้ struct keyword
• ตั้งชื่อแบบ PascalCase (ตัวพิมพ์ใหญ่ขึ้นต้นแต่ละคำ)
• แต่ละ field มี name: Type

📦 Struct Memory Layout

สร้าง Instance

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice"),
        active: true,
        sign_in_count: 1,
    };

    println!("Username: {}", user1.username);
    println!("Email: {}", user1.email);
}

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

เข้าถึงและแก้ไข Fields

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice"),
        active: true,
        sign_in_count: 1,
    };

    // อ่านค่า
    println!("Email: {}", user1.email);

    // แก้ไขค่า (ต้อง mut)
    user1.email = String::from("new@example.com");

    println!("New email: {}", user1.email);
}

หมายเหตุ: ทั้ง instance ต้องเป็น mut ไม่สามารถ mut แค่บาง field ได้

Field Init Shorthand

ถ้าชื่อ parameter ตรงกับ field ไม่ต้องเขียนซ้ำ:

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn build_user(email: String, username: String) -> User {
    User {
        email,    // แทน email: email
        username, // แทน username: username
        active: true,
        sign_in_count: 1,
    }
}

Struct Update Syntax

สร้าง instance ใหม่จาก instance เดิม:

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice"),
        active: true,
        sign_in_count: 1,
    };

    // สร้าง user2 โดยใช้ค่าจาก user1
    let user2 = User {
        email: String::from("bob@example.com"),
        ..user1 // ใช้ค่าที่เหลือจาก user1
    };

    // ⚠️ user1.username ถูก move ไป user2 แล้ว!
    // println!("{}", user1.username); // ❌ Error
    println!("{}", user1.email); // ✅ OK (ไม่ได้ move)
}

Tuple Structs

Struct ที่ไม่มีชื่อ field:

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

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

    println!("R: {}", black.0);
    println!("X: {}", origin.0);
}

หมายเหตุ: Color และ Point เป็นคนละ type แม้จะมีโครงสร้างเหมือนกัน

Unit-like Structs

Struct ที่ไม่มี field:

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

มีประโยชน์เมื่อต้องการ implement trait โดยไม่ต้องเก็บข้อมูล

Debug Printing

เพิ่ม #[derive(Debug)] เพื่อ print struct:

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

fn main() {
    let rect = Rectangle {
        width: 30,
        height: 50,
    };

    println!("{:?}", rect);   // Debug format
    println!("{:#?}", rect);  // Pretty debug format
}

Output:

Rectangle { width: 30, height: 50 }
Rectangle {
    width: 30,
    height: 50,
}

ลองทำดู! 🎯

1. สร้าง struct Book ที่มี title, author, pages
2. สร้าง struct Point สำหรับพิกัด 2D
3. ใช้ #[derive(Debug)] และ print struct

สรุป

👉 ต่อไป: Methods

Methods

Methods คือ functions ที่ผูกกับ struct ใช้ impl block

นิยาม Method

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

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

fn main() {
    let rect = Rectangle {
        width: 30,
        height: 50,
    };

    println!("Area: {}", rect.area());
}

&self Parameter

&self เป็น shorthand สำหรับ self: &Self:

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

impl Rectangle {
    // อ่านค่าอย่างเดียว
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // แก้ไขค่า
    fn double_width(&mut self) {
        self.width *= 2;
    }

    // รับ ownership (หลังเรียก instance จะใช้ไม่ได้)
    fn destroy(self) {
        println!("Destroying {:?}", self);
    }
}

Methods ที่มี Parameters

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

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

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 10, height: 40 };
    let rect3 = Rectangle { width: 60, height: 45 };

    println!("rect1 can hold rect2: {}", rect1.can_hold(&rect2)); // true
    println!("rect1 can hold rect3: {}", rect1.can_hold(&rect3)); // false
}

หลาย impl Blocks

สามารถแยก methods เป็นหลาย impl blocks ได้:

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

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

impl Rectangle {
    fn perimeter(&self) -> u32 {
        2 * (self.width + self.height)
    }
}

Method Chaining

ออกแบบ methods ที่ return &mut self เพื่อ chain ได้:

#[derive(Debug)]
struct Counter {
    value: i32,
}

impl Counter {
    fn new() -> Counter {
        Counter { value: 0 }
    }

    fn increment(&mut self) -> &mut Self {
        self.value += 1;
        self
    }

    fn add(&mut self, n: i32) -> &mut Self {
        self.value += n;
        self
    }
}

fn main() {
    let mut counter = Counter::new();

    counter
        .increment()
        .increment()
        .add(10);

    println!("{:?}", counter); // Counter { value: 12 }
}

Automatic Referencing

Rust จะเพิ่ม &, &mut, หรือ * อัตโนมัติเมื่อเรียก method:

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

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

fn main() {
    let rect = Rectangle { width: 30, height: 50 };

    // เทียบเท่ากัน:
    rect.area();
    (&rect).area();
}

ตัวอย่างจริง: Circle

use std::f64::consts::PI;

#[derive(Debug)]
struct Circle {
    radius: f64,
}

impl Circle {
    fn area(&self) -> f64 {
        PI * self.radius * self.radius
    }

    fn circumference(&self) -> f64 {
        2.0 * PI * self.radius
    }

    fn grow(&mut self, amount: f64) {
        self.radius += amount;
    }
}

fn main() {
    let mut circle = Circle { radius: 5.0 };

    println!("Radius: {}", circle.radius);
    println!("Area: {:.2}", circle.area());
    println!("Circumference: {:.2}", circle.circumference());

    circle.grow(2.5);
    println!("After grow - Area: {:.2}", circle.area());
}

ลองทำดู! 🎯

1. เพิ่ม method is_square(&self) ให้ Rectangle
2. สร้าง struct BankAccount พร้อม methods deposit, withdraw
3. สร้าง method chain สำหรับ builder pattern

สรุป

👉 ต่อไป: Associated Functions

Associated Functions

Associated Functions คือ functions ใน impl block ที่ไม่มี self เรียกด้วย ::

Syntax

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

impl Rectangle {
    fn new(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}

fn main() {
    let rect = Rectangle::new(30, 50); // ใช้ :: ไม่ใช่ .

    println!("{:?}", rect);
}

Constructor Pattern

Associated functions มักใช้เป็น constructor:

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

impl Rectangle {
    // Constructor หลัก
    fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }

    // Constructor สำหรับสี่เหลี่ยมจัตุรัส
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }

    // Constructor default
    fn default() -> Self {
        Self {
            width: 1,
            height: 1,
        }
    }
}

fn main() {
    let rect = Rectangle::new(30, 50);
    let square = Rectangle::square(10);
    let default = Rectangle::default();

    println!("{:?}", rect);
    println!("{:?}", square);
    println!("{:?}", default);
}

หมายเหตุ: ใช้ Self แทนชื่อ struct ได้ใน impl block

Methods vs Associated Functions

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

impl Rectangle {
    // Associated Function (ไม่มี self)
    fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }

    // Method (มี &self)
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle::new(10, 20); // ::
    let area = rect.area();             // .
}

ตัวอย่าง: String::from

String::from เป็น associated function ที่เราใช้บ่อย:

fn main() {
    let s = String::from("hello"); // associated function

    let len = s.len(); // method
}

ตัวอย่างจริง: User

#[derive(Debug)]
struct User {
    username: String,
    email: String,
    active: bool,
}

impl User {
    // Constructor
    fn new(username: String, email: String) -> Self {
        Self {
            username,
            email,
            active: true,
        }
    }

    // สร้างจาก email (extract username)
    fn from_email(email: String) -> Self {
        let username = email
            .split('@')
            .next()
            .unwrap_or("unknown")
            .to_string();

        Self::new(username, email)
    }

    // Methods
    fn is_active(&self) -> bool {
        self.active
    }

    fn deactivate(&mut self) {
        self.active = false;
    }
}

fn main() {
    let user1 = User::new(
        String::from("alice"),
        String::from("alice@example.com")
    );

    let user2 = User::from_email(String::from("bob@example.com"));

    println!("{:?}", user1);
    println!("{:?}", user2);
}

Builder Pattern

ใช้ associated functions และ methods ร่วมกัน:

#[derive(Debug)]
struct Car {
    brand: String,
    model: String,
    year: u32,
    color: String,
}

impl Car {
    fn builder() -> CarBuilder {
        CarBuilder::default()
    }
}

#[derive(Default)]
struct CarBuilder {
    brand: String,
    model: String,
    year: u32,
    color: String,
}

impl CarBuilder {
    fn brand(mut self, brand: &str) -> Self {
        self.brand = brand.to_string();
        self
    }

    fn model(mut self, model: &str) -> Self {
        self.model = model.to_string();
        self
    }

    fn year(mut self, year: u32) -> Self {
        self.year = year;
        self
    }

    fn color(mut self, color: &str) -> Self {
        self.color = color.to_string();
        self
    }

    fn build(self) -> Car {
        Car {
            brand: self.brand,
            model: self.model,
            year: self.year,
            color: self.color,
        }
    }
}

fn main() {
    let car = Car::builder()
        .brand("Toyota")
        .model("Camry")
        .year(2024)
        .color("Blue")
        .build();

    println!("{:?}", car);
}

ลองทำดู! 🎯

1. สร้าง Point::origin() ที่ return Point(0, 0)
2. สร้าง Circle::with_radius(r) constructor
3. Implement builder pattern สำหรับ struct ที่คุณสร้าง

สรุปบทที่ 6

👉 ต่อไป: บทที่ 7: Enums & Pattern Matching

บทที่ 7: Enums & Pattern Matching

Enums ช่วยให้เราแสดงค่าที่เป็นไปได้หลายแบบ และ Pattern Matching ช่วยจัดการแต่ละแบบ

สิ่งที่จะได้เรียนรู้

Enums คืออะไร?

Enum แสดงว่าค่าเป็น หนึ่งใน หลายตัวเลือก:

#![allow(unused)]
fn main() {
enum Direction {
    North,
    South,
    East,
    West,
}
}

ค่าของ Direction ต้องเป็น North, South, East, หรือ West เท่านั้น

เริ่มกันเลย!

👉 การสร้าง Enum

การสร้าง Enum

Syntax พื้นฐาน

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(four);
    route(six);
}

fn route(ip_kind: IpAddrKind) {
    // ...
}

Enum กับ Data

Variants สามารถมีข้อมูลแนบได้:

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
}

Variants หลายแบบ

แต่ละ variant มีข้อมูลต่างกันได้:

enum Message {
    Quit,                       // ไม่มีข้อมูล
    Move { x: i32, y: i32 },    // anonymous struct
    Write(String),              // String
    ChangeColor(i32, i32, i32), // 3 integers
}

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move { x: 10, y: 20 };
    let m3 = Message::Write(String::from("Hello"));
    let m4 = Message::ChangeColor(255, 0, 0);
}

Methods บน Enum

เหมือนกับ struct:

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

impl Message {
    fn call(&self) {
        // method body
        println!("Message received!");
    }
}

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

เปรียบเทียบ Enum vs Struct

ใช้ Struct + Enum

enum IpAddrKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

fn main() {
    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };
}

ใช้ Enum alone (ดีกว่า!)

enum IpAddr {
    V4(String),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(String::from("127.0.0.1"));
}

ตัวอย่างจริง: WebEvent

enum WebEvent {
    PageLoad,
    PageUnload,
    KeyPress(char),
    Paste(String),
    Click { x: i64, y: i64 },
}

fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("Page loaded"),
        WebEvent::PageUnload => println!("Page unloaded"),
        WebEvent::KeyPress(c) => println!("Key pressed: {}", c),
        WebEvent::Paste(s) => println!("Pasted: {}", s),
        WebEvent::Click { x, y } => println!("Clicked at ({}, {})", x, y),
    }
}

fn main() {
    let press = WebEvent::KeyPress('x');
    let click = WebEvent::Click { x: 20, y: 80 };

    inspect(press);
    inspect(click);
}

ลองทำดู! 🎯

1. สร้าง enum TrafficLight (Red, Yellow, Green)
2. สร้าง enum Shape ที่มี Circle(radius), Rectangle(w, h)
3. เพิ่ม method area() ให้ Shape

สรุป

👉 ต่อไป: Option<T>

Option<T>

Option<T> เป็น enum มาตรฐานที่ใช้แทน null ในภาษาอื่น

ปัญหาของ Null

ในภาษาอื่น null ทำให้เกิด bugs มากมาย:

// JavaScript
let name = null;
console.log(name.length); // 💥 Crash!

Rust ไม่มี null แต่ใช้ Option<T> แทน

นิยามของ Option

#![allow(unused)]
fn main() {
enum Option<T> {
    None,    // ไม่มีค่า
    Some(T), // มีค่า
}
}

หมายเหตุ: Option, Some, None อยู่ใน prelude ใช้ได้เลยโดยไม่ต้อง import

การใช้งาน Option

fn main() {
    let some_number: Option<i32> = Some(5);
    let some_string: Option<&str> = Some("hello");
    let absent_number: Option<i32> = None;

    println!("{:?}", some_number);  // Some(5)
    println!("{:?}", some_string);  // Some("hello")
    println!("{:?}", absent_number); // None
}

ทำไม Option ดีกว่า Null?

Compiler บังคับให้จัดการ

fn main() {
    let x: i32 = 5;
    let y: Option<i32> = Some(5);

    // let sum = x + y; // ❌ Error! cannot add i32 and Option<i32>
}

ต้อง “แกะ” Option ก่อนใช้ → บังคับให้คิดเรื่อง None

การจัดการ Option

1. match

fn main() {
    let x: Option<i32> = Some(5);

    match x {
        Some(value) => println!("Value: {}", value),
        None => println!("No value"),
    }
}

2. if let

fn main() {
    let x: Option<i32> = Some(5);

    if let Some(value) = x {
        println!("Value: {}", value);
    }
}

3. unwrap (ระวัง!)

fn main() {
    let x: Option<i32> = Some(5);
    let value = x.unwrap(); // ✅ ได้ 5

    let y: Option<i32> = None;
    // let value2 = y.unwrap(); // 💥 Panic!
}

4. unwrap_or (ปลอดภัยกว่า)

fn main() {
    let x: Option<i32> = Some(5);
    let y: Option<i32> = None;

    println!("{}", x.unwrap_or(0)); // 5
    println!("{}", y.unwrap_or(0)); // 0 (default)
}

5. map

fn main() {
    let x: Option<i32> = Some(5);

    let doubled = x.map(|v| v * 2);

    println!("{:?}", doubled); // Some(10)
}

Methods ที่ใช้บ่อย

fn main() {
    let x: Option<i32> = Some(5);
    let y: Option<i32> = None;

    println!("x is_some: {}", x.is_some()); // true
    println!("y is_none: {}", y.is_none()); // true

    // Chain operations
    let result = x
        .map(|v| v * 2)      // Some(10)
        .map(|v| v + 1)      // Some(11)
        .unwrap_or(0);       // 11

    println!("Result: {}", result);
}

ตัวอย่างจริง: หาค่าใน Array

fn find_item(items: &[i32], target: i32) -> Option<usize> {
    for (index, &item) in items.iter().enumerate() {
        if item == target {
            return Some(index);
        }
    }
    None
}

fn main() {
    let numbers = [1, 2, 3, 4, 5];

    match find_item(&numbers, 3) {
        Some(index) => println!("Found at index {}", index),
        None => println!("Not found"),
    }
}

ตัวอย่างจริง: Division

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    let result1 = divide(10.0, 2.0);
    let result2 = divide(10.0, 0.0);

    println!("{:?}", result1); // Some(5.0)
    println!("{:?}", result2); // None
}

ลองทำดู! 🎯

1. เขียน function first(vec: &Vec<i32>) -> Option<i32>
2. เขียน function parse_number(s: &str) -> Option<i32>
3. Chain หลาย Option methods ด้วยกัน

สรุป

👉 ต่อไป: Match Expression

Match Expression

match เป็น control flow ที่ทรงพลังใน Rust ใช้เปรียบเทียบค่ากับหลาย patterns

Syntax

match value {
    pattern1 => expression1,
    pattern2 => expression2,
    _ => default,
}

Match กับ Enum

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {
    let coin = Coin::Dime;
    println!("Value: {} cents", value_in_cents(coin));
}

Exhaustive Matching

match ต้องครอบคลุมทุกกรณี:

#![allow(unused)]
fn main() {
enum Color {
    Red,
    Green,
    Blue,
}

fn describe(color: Color) {
    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        // ❌ Error: pattern `Blue` not covered
    }
}
}

แก้ไข

#![allow(unused)]
fn main() {
enum Color {
    Red,
    Green,
    Blue,
}

fn describe(color: Color) {
    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        Color::Blue => println!("Blue"),
    }
}
}

_ (Catch-all)

ใช้ _ จับ patterns ที่เหลือ:

fn main() {
    let number = 13;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Something else"),
    }
}

Match กับ Binding

ดึงค่าจาก enum:

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

fn process(msg: Message) {
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => {
            println!("Move to ({}, {})", x, y);
        }
        Message::Write(text) => {
            println!("Text: {}", text);
        }
    }
}

fn main() {
    process(Message::Move { x: 10, y: 20 });
    process(Message::Write(String::from("Hello")));
}

Match กับ Option

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);

    println!("{:?}", six);  // Some(6)
    println!("{:?}", none); // None
}

Match Guards

เพิ่มเงื่อนไขให้ pattern:

fn main() {
    let num = Some(4);

    match num {
        Some(x) if x < 5 => println!("Less than 5: {}", x),
        Some(x) => println!("5 or more: {}", x),
        None => println!("None"),
    }
}

@ Binding

จับค่าพร้อมทั้งตรวจ pattern:

fn main() {
    let msg = Message::Move { x: 5, y: 10 };

    match msg {
        Message::Move { x: x_val @ 0..=10, y } => {
            println!("x ({}) is in range, y = {}", x_val, y);
        }
        Message::Move { x, y } => {
            println!("x ({}) is out of range, y = {}", x, y);
        }
        _ => {}
    }
}

enum Message {
    Move { x: i32, y: i32 },
}

Multiple Patterns

ใช้ | เพื่อ match หลาย patterns:

fn main() {
    let n = 3;

    match n {
        1 | 2 | 3 => println!("One, two, or three"),
        4..=10 => println!("Four to ten"),
        _ => println!("Something else"),
    }
}

Match เป็น Expression

fn main() {
    let x = 1;

    let message = match x {
        1 => "one",
        2 => "two",
        _ => "other",
    };

    println!("{}", message);
}

ตัวอย่างจริง: Command Processing

enum Command {
    Start,
    Stop,
    Speed(u32),
    Position { x: i32, y: i32 },
}

fn execute(cmd: Command) -> String {
    match cmd {
        Command::Start => String::from("Starting..."),
        Command::Stop => String::from("Stopping..."),
        Command::Speed(s) if s > 100 => format!("Too fast! {}", s),
        Command::Speed(s) => format!("Setting speed to {}", s),
        Command::Position { x, y } => format!("Moving to ({}, {})", x, y),
    }
}

fn main() {
    println!("{}", execute(Command::Start));
    println!("{}", execute(Command::Speed(50)));
    println!("{}", execute(Command::Speed(150)));
    println!("{}", execute(Command::Position { x: 10, y: 20 }));
}

ลองทำดู! 🎯

1. เขียน match สำหรับ Option<String> ที่ print ความยาว
2. เขียน match ที่ใช้ guard เช็คค่าบวก/ลบ
3. เขียน function ที่ return String ด้วย match

สรุป

👉 ต่อไป: if let & while let

if let & while let

if let และ while let เป็นทางเลือกที่กระชับสำหรับ match เมื่อสนใจแค่ pattern เดียว

ปัญหา: Match ยาวไป

fn main() {
    let some_value: Option<i32> = Some(3);

    // ยาวเกินไปสำหรับแค่ pattern เดียว
    match some_value {
        Some(value) => println!("Value: {}", value),
        _ => (),  // ไม่ทำอะไร
    }
}

if let

fn main() {
    let some_value: Option<i32> = Some(3);

    // กระชับกว่า!
    if let Some(value) = some_value {
        println!("Value: {}", value);
    }
}

Syntax

if let PATTERN = EXPRESSION {
    // ทำเมื่อ match
}

หรือพร้อม else:

if let PATTERN = EXPRESSION {
    // ทำเมื่อ match
} else {
    // ทำเมื่อไม่ match
}

if let กับ else

fn main() {
    let some_value: Option<i32> = None;

    if let Some(value) = some_value {
        println!("Value: {}", value);
    } else {
        println!("No value!");
    }
}

เทียบเท่ากับ:

match some_value {
    Some(value) => println!("Value: {}", value),
    _ => println!("No value!"),
}

if let กับ Enum

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

fn main() {
    let msg = Message::Move { x: 10, y: 20 };

    if let Message::Move { x, y } = msg {
        println!("Moving to ({}, {})", x, y);
    }

    let msg2 = Message::Write(String::from("hello"));

    if let Message::Write(text) = msg2 {
        println!("Message: {}", text);
    }
}

while let

ทำซ้ำตราบใดที่ pattern ยัง match:

fn main() {
    let mut stack = Vec::new();

    stack.push(1);
    stack.push(2);
    stack.push(3);

    // pop() returns Option<T>
    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

Output:

3
2
1

ตัวอย่าง: Iterator

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let mut iter = numbers.iter();

    while let Some(num) = iter.next() {
        println!("{}", num);
    }
}

let else (Rust 1.65+)

Unwrap หรือ return เร็ว:

fn get_length(s: Option<String>) -> usize {
    let Some(text) = s else {
        return 0;  // ต้อง return, break, continue, panic
    };

    text.len()
}

fn main() {
    println!("{}", get_length(Some(String::from("hello")))); // 5
    println!("{}", get_length(None)); // 0
}

เปรียบเทียบ

ใช้ match เมื่อ:

• มีหลาย patterns
• ต้องการให้ compiler บังคับครบทุกกรณี

ใช้ if let เมื่อ:

• สนใจแค่ pattern เดียว
• ต้องการความกระชับ

ตัวอย่างจริง

fn main() {
    let config_max: Option<u8> = Some(100);

    // if let - กระชับ
    if let Some(max) = config_max {
        println!("Maximum is {}", max);
    }

    // Regular if - ใช้ไม่ได้!
    // if config_max.is_some() {
    //     let max = config_max.unwrap();  // clunky
    //     println!("Maximum is {}", max);
    // }
}

Chained if let

fn main() {
    let maybe_number: Option<i32> = Some(42);
    let maybe_string: Option<&str> = Some("hello");

    if let Some(n) = maybe_number {
        if let Some(s) = maybe_string {
            println!("Number: {}, String: {}", n, s);
        }
    }
}

หรือใช้ && (Rust 1.53+):

fn main() {
    let maybe_number: Option<i32> = Some(42);
    let maybe_string: Option<&str> = Some("hello");

    if let (Some(n), Some(s)) = (maybe_number, maybe_string) {
        println!("Number: {}, String: {}", n, s);
    }
}

ลองทำดู! 🎯

1. เขียน if let สำหรับ Option<String>
2. ใช้ while let pop จาก Vec
3. แปลง match ที่มี 2 arms เป็น if let else

สรุปบทที่ 7

👉 ต่อไป: บทที่ 8: Collections

บทที่ 8: Collections - คอลเลกชัน

Collections เก็บข้อมูลหลายค่า ต่างจาก array/tuple ที่ขนาดคงที่ collections ขยายได้

สิ่งที่จะได้เรียนรู้

เมื่อไหร่ใช้อะไร?

เริ่มกันเลย!

👉 Vec<T>

Vec<T> - Vector

Vector เป็น dynamic array ที่ขยายขนาดได้

📊 Collections Comparison

📦 Vector Memory Layout

+-------------------------------------------------------------------+
|                    Vec<T> Memory Structure                        |
+-------------------------------------------------------------------+
|                                                                   |
|   Stack                          Heap                             |
|   -----                          ----                             |
|   +-------------+                                                 |
|   | ptr --------+--------------> +---+---+---+---+---+            |
|   | len = 3     |                | 1 | 2 | 3 |   |   |            |
|   | capacity = 5|                +---+---+---+---+---+            |
|   +-------------+                  ^           ^                  |
|                                    |           |                  |
|                              used (len)   allocated (capacity)    |
|                                                                   |
+-------------------------------------------------------------------+

สร้าง Vector

fn main() {
    // สร้าง vector ว่าง
    let v1: Vec<i32> = Vec::new();

    // สร้างด้วย vec! macro
    let v2 = vec![1, 2, 3];

    println!("{:?}", v1); // []
    println!("{:?}", v2); // [1, 2, 3]
}

เพิ่มข้อมูล

fn main() {
    let mut v = Vec::new();

    v.push(1);
    v.push(2);
    v.push(3);

    println!("{:?}", v); // [1, 2, 3]
}

เข้าถึงข้อมูล

แบบที่ 1: Indexing

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let third = &v[2];
    println!("Third element: {}", third);

    // ⚠️ panic ถ้า index ไม่มี!
    // let hundred = &v[100]; // 💥 panic!
}

แบบที่ 2: get() (ปลอดภัยกว่า)

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    match v.get(2) {
        Some(value) => println!("Third: {}", value),
        None => println!("No element"),
    }

    // v.get(100) returns None (ไม่ panic)
    if let Some(value) = v.get(100) {
        println!("Found: {}", value);
    } else {
        println!("Not found");
    }
}

วนลูป

Immutable iteration

fn main() {
    let v = vec![1, 2, 3];

    for i in &v {
        println!("{}", i);
    }

    println!("v still accessible: {:?}", v);
}

Mutable iteration

fn main() {
    let mut v = vec![1, 2, 3];

    for i in &mut v {
        *i *= 2; // dereference with *
    }

    println!("{:?}", v); // [2, 4, 6]
}

Methods ที่ใช้บ่อย

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    println!("len: {}", v.len());       // 5
    println!("is_empty: {}", v.is_empty()); // false
    println!("first: {:?}", v.first()); // Some(1)
    println!("last: {:?}", v.last());   // Some(5)

    // pop - ลบและ return ตัวสุดท้าย
    let last = v.pop();
    println!("popped: {:?}", last); // Some(5)
    println!("v: {:?}", v); // [1, 2, 3, 4]

    // insert - แทรกที่ตำแหน่ง
    v.insert(1, 10);
    println!("after insert: {:?}", v); // [1, 10, 2, 3, 4]

    // remove - ลบที่ตำแหน่ง
    let removed = v.remove(1);
    println!("removed: {}", removed); // 10
    println!("after remove: {:?}", v); // [1, 2, 3, 4]

    // contains
    println!("contains 3: {}", v.contains(&3)); // true
}

Vector กับ Enum

เก็บหลาย types ด้วย enum:

enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

fn main() {
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Float(10.12),
        SpreadsheetCell::Text(String::from("hello")),
    ];

    for cell in &row {
        match cell {
            SpreadsheetCell::Int(i) => println!("Int: {}", i),
            SpreadsheetCell::Float(f) => println!("Float: {}", f),
            SpreadsheetCell::Text(s) => println!("Text: {}", s),
        }
    }
}

Ownership และ Vector

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let first = &v[0]; // borrow

    // v.push(6); // ❌ Error! cannot borrow v as mutable

    println!("First: {}", first);
}

ทำไม? เพราะ push อาจทำให้ vector ย้ายที่ในเมมโมรี่ ทำให้ reference เดิมไม่ valid

ลองทำดู! 🎯

1. สร้าง vector ของเลข 1-10 แล้วคำนวณผลรวม
2. สร้าง function ที่รับ &mut Vec<i32> และกรองเอาเฉพาะเลขคู่
3. ใช้ enum เก็บหลาย types ใน vector

สรุป

👉 ต่อไป: String

String

String ใน Rust มี 2 แบบหลัก:

สร้าง String

fn main() {
    // จาก string literal
    let s1 = String::from("Hello");
    let s2 = "Hello".to_string();

    // String ว่าง
    let s3 = String::new();

    // จาก format!
    let s4 = format!("Hello, {}!", "World");

    println!("{}, {}, {}, {}", s1, s2, s3, s4);
}

String vs &str

fn main() {
    let s1: String = String::from("Hello"); // owned
    let s2: &str = "Hello";                 // borrowed (string literal)
    let s3: &str = &s1;                     // borrowed from String

    // String -> &str (automatic coercion)
    greet(&s1);
    greet(s2);

    // &str -> String
    let s4: String = s2.to_string();
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

แนะนำ: ใช้ &str เป็น parameter, ใช้ String เมื่อต้อง own ข้อมูล

ต่อ String

push_str และ push

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

    s.push_str(", World"); // ต่อ string
    s.push('!');           // ต่อ char

    println!("{}", s); // Hello, World!
}

+ Operator

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("World!");

    let s3 = s1 + &s2; // s1 ถูก move!

    // println!("{}", s1); // ❌ Error: s1 was moved
    println!("{}", s2); // ✅ OK
    println!("{}", s3); // Hello, World!
}

หมายเหตุ: + รับ String ซ้าย และ &str ขวา

format! (แนะนำ)

fn main() {
    let s1 = String::from("Hello");
    let s2 = String::from("World");

    // format! ไม่ move อะไรเลย
    let s3 = format!("{}, {}!", s1, s2);

    println!("{}", s1); // ✅ OK
    println!("{}", s2); // ✅ OK
    println!("{}", s3); // Hello, World!
}

UTF-8 และการ Index

String ใน Rust เป็น UTF-8 → ไม่สามารถ index ด้วย s[0] ได้!

fn main() {
    let hello = String::from("สวัสดี");

    // let first = hello[0]; // ❌ Error!

    // ใช้ slicing ได้ (แต่ระวัง!)
    // let first_byte = &hello[0..1]; // 💥 panic! กลาง character
    let first_char = &hello[0..3]; // ✅ "ส" (3 bytes)

    println!("First char: {}", first_char);
}

การวนลูป

fn main() {
    let hello = String::from("สวัสดี");

    // วนตาม characters
    for c in hello.chars() {
        println!("{}", c);
    }

    // วนตาม bytes
    for b in hello.bytes() {
        println!("{}", b);
    }
}

Methods ที่ใช้บ่อย

fn main() {
    let s = String::from("  Hello, World!  ");

    // Length
    println!("len: {}", s.len());              // 18 (bytes)
    println!("chars: {}", s.chars().count()); // 18 (characters)

    // trim
    println!("trimmed: '{}'", s.trim());

    // contains, starts_with, ends_with
    println!("contains 'World': {}", s.contains("World"));

    // replace
    println!("replaced: {}", s.replace("World", "Rust"));

    // split
    for word in s.trim().split(',') {
        println!("word: '{}'", word.trim());
    }

    // to_uppercase, to_lowercase
    println!("upper: {}", s.to_uppercase());
    println!("lower: {}", s.to_lowercase());
}

ตัวอย่างจริง: Parse และ Format

fn main() {
    // Parse string to number
    let num_str = "42";
    let num: i32 = num_str.parse().expect("Not a number");
    println!("Parsed: {}", num);

    // Format number to string
    let formatted = format!("The answer is {}", num);
    println!("{}", formatted);

    // Format with padding
    let padded = format!("{:0>5}", num); // "00042"
    println!("Padded: {}", padded);
}

ลองทำดู! 🎯

1. สร้าง function ที่นับคำใน string
2. สร้าง function ที่ reverse string
3. สร้าง function ที่ตรวจสอบว่าเป็น palindrome หรือไม่

สรุป

👉 ต่อไป: HashMap

HashMap<K, V>

HashMap เก็บข้อมูลแบบ key-value pairs

สร้าง HashMap

use std::collections::HashMap;

fn main() {
    // สร้าง HashMap ว่าง
    let mut scores: HashMap<String, i32> = HashMap::new();

    // เพิ่มข้อมูล
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    println!("{:?}", scores);
}

หมายเหตุ: ต้อง use std::collections::HashMap;

สร้างจาก Iterator

use std::collections::HashMap;

fn main() {
    let teams = vec![String::from("Blue"), String::from("Yellow")];
    let initial_scores = vec![10, 50];

    let scores: HashMap<_, _> = teams
        .into_iter()
        .zip(initial_scores.into_iter())
        .collect();

    println!("{:?}", scores);
}

เข้าถึงข้อมูล

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // get returns Option<&V>
    let team_name = String::from("Blue");

    if let Some(score) = scores.get(&team_name) {
        println!("Blue score: {}", score);
    }

    // get_key_value returns Option<(&K, &V)>
    if let Some((key, value)) = scores.get_key_value(&team_name) {
        println!("{}: {}", key, value);
    }
}

วนลูป

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

Ownership

use std::collections::HashMap;

fn main() {
    let field_name = String::from("Color");
    let field_value = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_name, field_value);

    // field_name และ field_value ถูก move แล้ว!
    // println!("{}", field_name); // ❌ Error
}

ใช้ references หรือ clone ถ้าต้องการเก็บ:

use std::collections::HashMap;

fn main() {
    let field_name = String::from("Color");
    let field_value = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_name.clone(), field_value.clone());

    println!("{}: {}", field_name, field_value); // ✅ OK
}

อัปเดตค่า

Overwrite

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25); // overwrite!

    println!("{:?}", scores); // {"Blue": 25}
}

Insert ถ้าไม่มี (entry)

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);

    // ใส่ค่าเฉพาะเมื่อ key ไม่มี
    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50); // ไม่ทำอะไร

    println!("{:?}", scores); // {"Blue": 10, "Yellow": 50}
}

อัปเดตตามค่าเดิม

use std::collections::HashMap;

fn main() {
    let text = "hello world wonderful world";

    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{:?}", map);
    // {"hello": 1, "world": 2, "wonderful": 1}
}

Methods ที่ใช้บ่อย

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("a", 1);
    map.insert("b", 2);
    map.insert("c", 3);

    println!("len: {}", map.len());           // 3
    println!("is_empty: {}", map.is_empty()); // false
    println!("contains a: {}", map.contains_key("a")); // true

    // remove
    let removed = map.remove("a");
    println!("removed: {:?}", removed); // Some(1)

    // keys, values
    for key in map.keys() {
        println!("key: {}", key);
    }

    for value in map.values() {
        println!("value: {}", value);
    }

    // clear
    map.clear();
    println!("after clear: {:?}", map); // {}
}

ตัวอย่างจริง: นับความถี่

use std::collections::HashMap;

fn main() {
    let numbers = vec![1, 2, 3, 2, 1, 3, 3, 3, 4, 5];

    let mut frequency = HashMap::new();

    for num in numbers {
        *frequency.entry(num).or_insert(0) += 1;
    }

    // หาค่าที่มากที่สุด
    let (most_common, count) = frequency
        .iter()
        .max_by_key(|&(_, count)| count)
        .unwrap();

    println!("Most common: {} ({}x)", most_common, count);
    println!("All: {:?}", frequency);
}

ลองทำดู! 🎯

1. สร้าง phonebook ด้วย HashMap<String, String>
2. นับความถี่ของ characters ใน string
3. สร้าง group function ที่จัดกลุ่ม items

สรุปบทที่ 8

👉 ต่อไป: บทที่ 9: Error Handling

บทที่ 9: Error Handling - การจัดการ Error

Rust มีระบบจัดการ error ที่แข็งแกร่ง แบ่งเป็น 2 ประเภท:

สิ่งที่จะได้เรียนรู้

เริ่มกันเลย!

👉 panic!

panic! - Unrecoverable Errors

panic! หยุดโปรแกรมทันทีเมื่อเกิด error ที่จัดการไม่ได้

🚨 Error Handling Decision Tree

+-------------------------------------------------------------------+
|                    Error Handling in Rust                         |
+-------------------------------------------------------------------+
|                                                                   |
|                      +--------------+                             |
|                      | Error occurs |                             |
|                      +------+-------+                             |
|                             |                                     |
|           +-----------------+-----------------+                   |
|           |                                   |                   |
|           v                                   v                   |
|   +---------------+                   +---------------+           |
|   | Recoverable?  |                   | Unrecoverable |           |
|   | Can recover   |                   | Cannot recover|           |
|   +-------+-------+                   +-------+-------+           |
|           |                                   |                   |
|           v                                   v                   |
|   +---------------+                   +---------------+           |
|   | Result<T, E>  |                   |   panic!()    |           |
|   |               |                   |               |           |
|   | * File not    |                   | * Bug in code |           |
|   |   found       |                   | * Impossible  |           |
|   | * Parse error |                   |   state       |           |
|   | * Network     |                   | * Contract    |           |
|   |   timeout     |                   |   violation   |           |
|   +---------------+                   +---------------+           |
|                                                                   |
+-------------------------------------------------------------------+

เมื่อไหร่เกิด Panic?

1. เรียก panic! เอง

fn main() {
    panic!("crash and burn");
}

Output:

thread 'main' panicked at 'crash and burn', src/main.rs:2:5

2. Bug ในโค้ด

fn main() {
    let v = vec![1, 2, 3];
    v[99]; // 💥 panic! index out of bounds
}

Backtrace

ดู backtrace เพื่อหาที่มาของ panic:

RUST_BACKTRACE=1 cargo run
```text

```text
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99'
stack backtrace:
   0: std::panicking::begin_panic_handler
   1: core::panicking::panic_bounds_check
   2: <usize as core::slice::SliceIndex<[T]>>::index
   3: playground::main
             at src/main.rs:3:5

เมื่อไหร่ควรใช้ panic!

✅ ควรใช้

1. Prototyping - ตัวอย่างโค้ด, ทดลอง

fn main() {
    // ยังไม่ได้ implement
    todo!("implement this later");
}

2. Tests - เมื่อ test fail

#[test]
fn test_something() {
    assert_eq!(1, 2); // panic! ถ้าไม่เท่า
}

3. Unrecoverable situation - สถานการณ์ที่โปรแกรมต้องหยุด

#![allow(unused)]
fn main() {
fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Cannot divide by zero!");
    }
    a / b
}
}

4. Invalid state - ข้อมูลอยู่ในสถานะที่ไม่ถูกต้อง

#![allow(unused)]
fn main() {
fn process_age(age: i32) {
    if age < 0 || age > 150 {
        panic!("Invalid age: {}", age);
    }
    // ...
}
}

❌ ไม่ควรใช้

1. Expected failures - เช่น file not found, network error
2. User input errors - ผู้ใช้พิมพ์ผิด
3. Recoverable errors - ลอง retry ได้

Rule of thumb: ถ้าผู้เรียกสามารถ handle error ได้ → ใช้ Result

💡 Best Practices: panic! vs Result

+---------------------------------------------------------+
|                  Error Handling Choice                  |
+---------------------------------------------------------+
|  panic!           |  Result<T, E>                       |
+-------------------+-------------------------------------+
|  * Bug in code    |  * File not found                   |
|  * Invalid state  |  * Network error                    |
|  * Tests          |  * User input error                 |
|  * Prototyping    |  * Parse error                      |
|  * Unrecoverable  |  * Recoverable errors               |
+-------------------+-------------------------------------+

unwrap และ expect

unwrap

fn main() {
    let x: Option<i32> = Some(5);
    let value = x.unwrap(); // ✅ 5

    let y: Option<i32> = None;
    // let value = y.unwrap(); // 💥 panic!
}

expect (ดีกว่า unwrap)

fn main() {
    let x: Option<i32> = None;

    // ให้ error message ที่ชัดเจน
    let value = x.expect("x should have a value");
}

Output:

thread 'main' panicked at 'x should have a value', src/main.rs:4:18

unreachable! และ todo!

fn main() {
    let level = 5;

    let description = match level {
        1..=5 => "beginner",
        6..=10 => "intermediate",
        11..=20 => "advanced",
        _ => unreachable!("level should be 1-20"),
    };

    // ยังไม่ได้ implement
    todo!("add more logic here");
}

ตัวอย่างจริง: Assertion

fn set_age(age: u32) {
    assert!(age <= 150, "Age {} is unrealistic", age);
    println!("Age set to {}", age);
}

fn main() {
    set_age(25);  // ✅ OK
    set_age(200); // 💥 panic!
}

ลองทำดู! 🎯

1. สร้าง function ที่ panic เมื่อได้รับค่าลบ
2. ใช้ expect แทน unwrap และให้ error message ที่ดี
3. ลองเปิด RUST_BACKTRACE=1 ดู backtrace

สรุป

👉 ต่อไป: Result<T, E>

Result<T, E>

Result ใช้จัดการ recoverable errors - error ที่สามารถ handle ได้

นิยาม

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),   // สำเร็จ มีค่า T
    Err(E),  // ล้มเหลว มี error E
}
}

ตัวอย่างพื้นฐาน

use std::fs::File;

fn main() {
    let result = File::open("hello.txt");

    let file = match result {
        Ok(file) => file,
        Err(error) => {
            panic!("Failed to open file: {:?}", error);
        }
    };

    println!("File opened: {:?}", file);
}

จัดการหลายประเภท Error

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let result = File::open("hello.txt");

    let file = match result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => {
                // สร้างไฟล์ใหม่ถ้าไม่มี
                match File::create("hello.txt") {
                    Ok(fc) => fc,
                    Err(e) => panic!("Cannot create file: {:?}", e),
                }
            }
            other_error => {
                panic!("Cannot open file: {:?}", other_error);
            }
        },
    };

    println!("File: {:?}", file);
}

Shortcuts: unwrap และ expect

unwrap

use std::fs::File;

fn main() {
    // panic ถ้า error
    let file = File::open("hello.txt").unwrap();
}

expect (แนะนำ)

use std::fs::File;

fn main() {
    // panic พร้อม message
    let file = File::open("hello.txt")
        .expect("Failed to open hello.txt");
}

Methods ที่ใช้บ่อย

fn main() {
    let ok_result: Result<i32, &str> = Ok(42);
    let err_result: Result<i32, &str> = Err("error");

    // is_ok, is_err
    println!("ok is_ok: {}", ok_result.is_ok());   // true
    println!("err is_err: {}", err_result.is_err()); // true

    // unwrap_or
    println!("ok: {}", ok_result.unwrap_or(0));   // 42
    println!("err: {}", err_result.unwrap_or(0)); // 0

    // unwrap_or_else
    let value = err_result.unwrap_or_else(|e| {
        println!("Error was: {}", e);
        -1
    });
    println!("value: {}", value); // -1

    // map - transform Ok value
    let doubled = ok_result.map(|x| x * 2);
    println!("doubled: {:?}", doubled); // Ok(84)

    // map_err - transform Err value
    let new_err = err_result.map_err(|e| format!("Error: {}", e));
    println!("new_err: {:?}", new_err); // Err("Error: error")
}

ok() และ err()

แปลง Result เป็น Option:

fn main() {
    let ok_result: Result<i32, &str> = Ok(42);
    let err_result: Result<i32, &str> = Err("error");

    // ok() -> Option<T>
    println!("{:?}", ok_result.ok());   // Some(42)
    println!("{:?}", err_result.ok());  // None

    // err() -> Option<E>
    println!("{:?}", ok_result.err());  // None
    println!("{:?}", err_result.err()); // Some("error")
}

and_then (Chaining)

fn square(x: i32) -> Result<i32, &'static str> {
    if x > 100 {
        Err("Too large to square")
    } else {
        Ok(x * x)
    }
}

fn main() {
    let result = Ok(5)
        .and_then(square)  // Ok(25)
        .and_then(square); // Ok(625)

    println!("{:?}", result); // Ok(625)

    let result2 = Ok(50)
        .and_then(square)   // Ok(2500)
        .and_then(square);  // Err("Too large to square")

    println!("{:?}", result2);
}

ตัวอย่างจริง: Parse Number

fn parse_and_double(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n: i32 = s.parse()?;
    Ok(n * 2)
}

fn main() {
    match parse_and_double("42") {
        Ok(n) => println!("Result: {}", n),
        Err(e) => println!("Error: {}", e),
    }

    match parse_and_double("abc") {
        Ok(n) => println!("Result: {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

ลองทำดู! 🎯

1. เขียน function divide(a, b) -> Result<f64, String> ที่ return Err เมื่อ b = 0
2. ใช้ and_then เพื่อ chain หลาย operations
3. แปลง string เป็น number แล้วบวกเลขสองตัว

สรุป

👉 ต่อไป: การส่งต่อ Error

การส่งต่อ Error (Propagating Errors)

เมื่อ function เจอ error อาจต้องการส่งต่อให้ caller จัดการ

วิธีดั้งเดิม: match

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let file_result = File::open("username.txt");

    let mut file = match file_result {
        Ok(file) => file,
        Err(e) => return Err(e), // ส่งต่อ error
    };

    let mut username = String::new();

    match file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e), // ส่งต่อ error
    }
}

ยาวไป! 😩

? Operator

? ทำให้โค้ดสั้นลง:

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?; // ส่งต่อถ้า Err
    let mut username = String::new();
    file.read_to_string(&mut username)?; // ส่งต่อถ้า Err
    Ok(username)
}

? ทำงานอย่างไร

let file = File::open("file.txt")?;

เทียบเท่ากับ:

let file = match File::open("file.txt") {
    Ok(f) => f,
    Err(e) => return Err(e.into()), // แปลง error type ด้วย
};

Chain ?

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("username.txt")?.read_to_string(&mut username)?;

    Ok(username)
}

หรือสั้นกว่านี้:

use std::fs;

fn read_username_from_file() -> Result<String, String> {
    fs::read_to_string("username.txt")
        .map_err(|e| e.to_string())
}

? กับ Option

ใช้ ? กับ Option ได้ด้วย:

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}

fn main() {
    println!("{:?}", last_char_of_first_line("Hello\nWorld")); // Some('o')
    println!("{:?}", last_char_of_first_line(""));             // None
}

? ใน main()

use std::fs::File;
use std::io;

fn main() -> Result<(), io::Error> {
    let _file = File::open("hello.txt")?;
    Ok(())
}

Error Conversion

? เรียก From::from() อัตโนมัติเพื่อแปลง error types:

use std::fs::File;
use std::io::{self, Read};

fn read_number_from_file() -> Result<i32, Box<dyn std::error::Error>> {
    let mut file = File::open("number.txt")?; // io::Error -> Box<dyn Error>
    let mut content = String::new();
    file.read_to_string(&mut content)?;       // io::Error -> Box<dyn Error>
    let number: i32 = content.trim().parse()?; // ParseIntError -> Box<dyn Error>
    Ok(number)
}

ตัวอย่างจริง: API Call

use std::fs;

fn get_config_value(key: &str) -> Result<String, String> {
    let content = fs::read_to_string("config.txt")
        .map_err(|e| format!("Cannot read config: {}", e))?;

    for line in content.lines() {
        let parts: Vec<&str> = line.split('=').collect();
        if parts.len() == 2 && parts[0].trim() == key {
            return Ok(parts[1].trim().to_string());
        }
    }

    Err(format!("Key '{}' not found", key))
}

fn main() {
    match get_config_value("database_url") {
        Ok(value) => println!("Found: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Early Return Pattern

fn process_data(data: &str) -> Result<String, &'static str> {
    if data.is_empty() {
        return Err("Data is empty");
    }

    let trimmed = data.trim();

    if trimmed.len() < 3 {
        return Err("Data too short");
    }

    Ok(trimmed.to_uppercase())
}

fn main() {
    println!("{:?}", process_data("  hello  ")); // Ok("HELLO")
    println!("{:?}", process_data(""));           // Err("Data is empty")
    println!("{:?}", process_data("ab"));         // Err("Data too short")
}

ลองทำดู! 🎯

1. เขียน function ที่อ่านไฟล์และ parse เป็น JSON (ใช้ ?)
2. Chain หลาย ? ในบรรทัดเดียว
3. สร้าง function ที่ return Result<T, Box<dyn Error>>

สรุป

👉 ต่อไป: Custom Error Types

Custom Error Types

สร้าง error types เองเพื่อให้มีข้อมูลมากขึ้นและจัดการได้ดีขึ้น

Simple String Error

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Cannot divide by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

Enum Error Type

#[derive(Debug)]
enum MathError {
    DivisionByZero,
    NegativeSquareRoot,
    Overflow,
}

fn divide(a: f64, b: f64) -> Result<f64, MathError> {
    if b == 0.0 {
        Err(MathError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

fn sqrt(x: f64) -> Result<f64, MathError> {
    if x < 0.0 {
        Err(MathError::NegativeSquareRoot)
    } else {
        Ok(x.sqrt())
    }
}

fn main() {
    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(MathError::DivisionByZero) => println!("Cannot divide by zero!"),
        Err(e) => println!("Other error: {:?}", e),
    }
}

Implement Display และ Error

use std::fmt;
use std::error::Error;

#[derive(Debug)]
enum AppError {
    NotFound(String),
    InvalidInput(String),
    DatabaseError(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::NotFound(item) => write!(f, "{} not found", item),
            AppError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
            AppError::DatabaseError(msg) => write!(f, "Database error: {}", msg),
        }
    }
}

impl Error for AppError {}

fn find_user(id: u32) -> Result<String, AppError> {
    if id == 0 {
        Err(AppError::InvalidInput("ID cannot be 0".to_string()))
    } else if id > 100 {
        Err(AppError::NotFound(format!("User {}", id)))
    } else {
        Ok(format!("User_{}", id))
    }
}

fn main() {
    match find_user(0) {
        Ok(user) => println!("Found: {}", user),
        Err(e) => println!("Error: {}", e),
    }

    match find_user(150) {
        Ok(user) => println!("Found: {}", user),
        Err(e) => println!("Error: {}", e),
    }
}

From Trait สำหรับ Error Conversion

use std::io;
use std::num::ParseIntError;
use std::fmt;
use std::error::Error;

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(ParseIntError),
    Custom(String),
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            MyError::Io(e) => write!(f, "IO error: {}", e),
            MyError::Parse(e) => write!(f, "Parse error: {}", e),
            MyError::Custom(msg) => write!(f, "{}", msg),
        }
    }
}

impl Error for MyError {}

// ทำให้ใช้ ? ได้
impl From<io::Error> for MyError {
    fn from(err: io::Error) -> MyError {
        MyError::Io(err)
    }
}

impl From<ParseIntError> for MyError {
    fn from(err: ParseIntError) -> MyError {
        MyError::Parse(err)
    }
}

fn read_number_from_file(path: &str) -> Result<i32, MyError> {
    let content = std::fs::read_to_string(path)?; // io::Error -> MyError
    let number: i32 = content.trim().parse()?;    // ParseIntError -> MyError
    Ok(number)
}

ใช้ thiserror Crate (แนะนำ)

# Cargo.toml
[dependencies]
thiserror = "1.0"

use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("User {0} not found")]
    NotFound(String),

    #[error("Invalid input: {0}")]
    InvalidInput(String),

    #[error("IO error")]
    Io(#[from] std::io::Error),

    #[error("Parse error")]
    Parse(#[from] std::num::ParseIntError),
}

fn process() -> Result<i32, AppError> {
    let content = std::fs::read_to_string("number.txt")?;
    let num: i32 = content.trim().parse()?;
    Ok(num)
}

ใช้ anyhow สำหรับ Applications

# Cargo.toml
[dependencies]
anyhow = "1.0"

use anyhow::{Context, Result};

fn read_config() -> Result<String> {
    let content = std::fs::read_to_string("config.txt")
        .context("Failed to read config file")?;
    Ok(content)
}

fn main() -> Result<()> {
    let config = read_config()?;
    println!("Config: {}", config);
    Ok(())
}

Best Practices

ลองทำดู! 🎯

1. สร้าง custom error enum สำหรับ HTTP status codes
2. Implement From สำหรับ convert ระหว่าง error types
3. ลองใช้ thiserror หรือ anyhow

สรุปบทที่ 9

👉 ต่อไป: บทที่ 10: Generics, Traits & Lifetimes

บทที่ 10: Generics, Traits & Lifetimes

บทนี้ครอบคลุม 3 หัวข้อสำคัญที่ทำให้ Rust ทรงพลัง

สิ่งที่จะได้เรียนรู้

เริ่มกันเลย!

👉 Generics

Generics

Generics ช่วยให้เขียนโค้ดที่ใช้ได้กับหลาย types โดยไม่ต้องเขียนซ้ำ

ปัญหา: Code Duplication

fn largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn largest_char(list: &[char]) -> char {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

โค้ดเหมือนกัน แต่ต่างแค่ type!

Generic Functions

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    println!("Largest number: {}", largest(&numbers));

    let chars = vec!['y', 'm', 'a', 'q'];
    println!("Largest char: {}", largest(&chars));
}

Syntax

fn function_name<T>(param: T) -> T {
    // ...
}

// Multiple type parameters
fn pair<T, U>(first: T, second: U) -> (T, U) {
    (first, second)
}

Generic Structs

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };

    // ❌ Error: x และ y ต้องเป็น type เดียวกัน
    // let mixed = Point { x: 5, y: 4.0 };
}

หลาย Type Parameters

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
    let mixed = Point { x: 5, y: 4.0 };  // ✅ OK
}

Generic Methods

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }

    fn y(&self) -> &T {
        &self.y
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("x = {}", p.x());
}

Methods สำหรับ Specific Type

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 3.0_f32, y: 4.0_f32 };
    println!("Distance: {}", p.distance_from_origin()); // 5.0

    let p2 = Point { x: 3, y: 4 };
    // p2.distance_from_origin(); // ❌ Error: not available for Point<i32>
}

Mix Type Parameters

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
    // Output: p3.x = 5, p3.y = c
}

Generic Enums

Standard library ใช้ generics มากมาย:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

สร้าง Generic Enum เอง

enum Either<L, R> {
    Left(L),
    Right(R),
}

fn main() {
    let a: Either<i32, String> = Either::Left(42);
    let b: Either<i32, String> = Either::Right(String::from("hello"));
}

Monomorphization

Rust compiles generics เป็น specific types ตอน compile time:

// เราเขียน:
fn id<T>(x: T) -> T { x }

fn main() {
    id(5);
    id("hello");
}

// Compiler สร้าง:
fn id_i32(x: i32) -> i32 { x }
fn id_str(x: &str) -> &str { x }

ผลลัพธ์: zero runtime cost! เหมือนเขียนแยกเอง

ตัวอย่างจริง: Container

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn len(&self) -> usize {
        self.items.len()
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);

    while let Some(item) = stack.pop() {
        println!("{}", item);
    }
    // Output: 3, 2, 1
}

Default Type Parameters

#![allow(unused)]
fn main() {
use std::ops::Add;

// Add trait มี default type parameter
// trait Add<Rhs = Self> { ... }

struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}
}

ลองทำดู! 🎯

1. สร้าง generic struct Pair<T> ที่มี first และ second
2. เพิ่ม method swap() ที่สลับ first และ second
3. สร้าง generic function ที่หาค่า min จาก slice

สรุป

ข้อดี

• ✅ ไม่ต้องเขียนโค้ดซ้ำ
• ✅ Type-safe
• ✅ Zero runtime cost (monomorphization)

👉 ต่อไป: Traits

Traits

Traits กำหนด behavior ที่ types ต้องมี คล้าย interfaces ในภาษาอื่น

นิยาม Trait

trait Summary {
    fn summarize(&self) -> String;
}

Implement Trait

trait Summary {
    fn summarize(&self) -> String;
}

struct Article {
    title: String,
    author: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{} by {}", self.title, self.author)
    }
}

struct Tweet {
    username: String,
    content: String,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("@{}: {}", self.username, self.content)
    }
}

fn main() {
    let article = Article {
        title: String::from("Rust is great"),
        author: String::from("Alice"),
        content: String::from("..."),
    };

    println!("{}", article.summarize());
}

Default Implementation

trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

struct Article {
    title: String,
}

impl Summary for Article {} // ใช้ default

fn main() {
    let article = Article { title: String::from("News") };
    println!("{}", article.summarize()); // (Read more...)
}

Traits as Parameters

fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

// หรือใช้ trait bound syntax
fn notify2<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

Derive Attribute

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1.clone();

    println!("{:?}", p1);
    println!("Equal: {}", p1 == p2);
}

Common derives: Debug, Clone, Copy, PartialEq, Eq, Hash, Default

สรุป

👉 ต่อไป: Trait Bounds

Trait Bounds

Trait Bounds จำกัดว่า generic type ต้องมี traits อะไรบ้าง

Basic Syntax

fn print_summary<T: Summary>(item: &T) {
    println!("{}", item.summarize());
}

// หรือ impl syntax
fn print_summary2(item: &impl Summary) {
    println!("{}", item.summarize());
}

Multiple Trait Bounds

fn notify<T: Summary + Display>(item: &T) {
    println!("Summary: {}", item.summarize());
    println!("Display: {}", item);
}

// impl syntax
fn notify2(item: &(impl Summary + Display)) {
    // ...
}

Where Clause

อ่านง่ายกว่าเมื่อมีหลาย bounds:

fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    // ...
    0
}

Return Trait

fn get_summarizable() -> impl Summary {
    Tweet {
        username: String::from("user"),
        content: String::from("hello"),
    }
}

หมายเหตุ: สามารถ return ได้แค่ type เดียว

Conditionally Implement Methods

#![allow(unused)]
fn main() {
use std::fmt::Display;

struct Pair<T> {
    x: T,
    y: T,
}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

// Methods only for types with Display + PartialOrd
impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("Larger: {}", self.x);
        } else {
            println!("Larger: {}", self.y);
        }
    }
}
}

สรุป

👉 ต่อไป: Lifetimes

Lifetimes

Lifetimes บอก compiler ว่า references มีอายุนานเท่าไหร่ ป้องกัน dangling references

⚠️ คำเตือน: Lifetime เป็นหัวข้อที่ยากที่สุดใน Rust

• ❌ อย่าใช้ 'static เพื่อแก้ทุก error
• ❌ อย่าเดา lifetime แบบสุ่ม
• ✅ เข้าใจปัญหาก่อนแก้
• ✅ ใช้ owned types (String แทน &str) เมื่อสงสัย

📋 Lifetime Cheatsheet

🧠 Mental Model

🔧 Common Patterns

1. Input → Output (ใช้ lifetime เดียวกัน)
   fn get_first<'a>(list: &'a [i32]) -> &'a i32

2. Struct เก็บ reference
   struct Parser<'a> { input: &'a str }

3. Multiple lifetimes (แยกคนละช่วง)
   fn foo<'a, 'b>(x: &'a str, y: &'b str) -> &'a str

4. 'static (อยู่ตลอดโปรแกรม)
   const MSG: &'static str = "Hello";

ปัญหา: Dangling Reference

fn main() {
    let r;                // declare r
    {
        let x = 5;
        r = &x;           // ❌ x จะหายเมื่อออกจาก scope
    }
    // println!("{}", r); // Error! r points to invalid memory
}

+---------------------------------------------------------+
|                 Dangling Reference                      |
+---------------------------------------------------------+
|                                                         |
|  let r; ---------+                                      |
|  {               |                                      |
|    let x = 5; <--+ r points to x                        |
|    r = &x;                                              |
|  } <-- x dropped here!                                  |
|                                                         |
|  r -> invalid memory                                    |
|                                                         |
+---------------------------------------------------------+

Rust compiler จะ reject โค้ดนี้เพราะ x ไม่อยู่แล้วเมื่อใช้ r

Lifetime Syntax

&i32        // reference
&'a i32     // reference with explicit lifetime 'a
&'a mut i32 // mutable reference with lifetime 'a

'a (อ่านว่า “tick a”) คือ lifetime parameter บอกว่า reference มีอายุเท่าไหร่

Lifetime ใน Functions

ปัญหา: Compiler ไม่รู้ว่า return อะไร

#![allow(unused)]
fn main() {
// ❌ Error: missing lifetime specifier
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
}

Compiler ไม่รู้ว่า return value จะอยู่นานเท่า x หรือ y

ทางแก้: Lifetime Annotations

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string is long");
    let string2 = String::from("xyz");

    let result = longest(&string1, &string2);
    println!("Longest: {}", result);
}

ความหมาย: Return value จะมีอายุเท่ากับ lifetime ที่สั้นกว่าระหว่าง x และ y

Lifetime กับ Scope

fn main() {
    let string1 = String::from("long string is long");

    {
        let string2 = String::from("xyz");
        let result = longest(&string1, &string2);
        println!("Longest: {}", result); // ✅ OK
    }

    // println!("{}", result); // ❌ result ไม่มีแล้ว
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Lifetime Elision Rules

Compiler มีกฎ 3 ข้อที่เดา lifetime ให้อัตโนมัติ:

Rule 1: Input Lifetimes

แต่ละ reference parameter ได้ lifetime ของตัวเอง:

fn foo(x: &i32)                    // -> fn foo<'a>(x: &'a i32)
fn foo(x: &i32, y: &i32)           // -> fn foo<'a, 'b>(x: &'a i32, y: &'b i32)

Rule 2: Single Input → Output

ถ้ามี input lifetime เดียว ใช้กับ output ทั้งหมด:

fn foo(x: &i32) -> &i32            // -> fn foo<'a>(x: &'a i32) -> &'a i32

Rule 3: Methods with &self

ถ้ามี &self หรือ &mut self ใช้ lifetime ของ self กับ output:

impl Foo {
    fn bar(&self, x: &str) -> &str // -> fn bar<'a, 'b>(&'a self, x: &'b str) -> &'a str
}

ถ้ากฎทั้งหมดไม่เพียงพอ → Compiler error → ต้องใส่ lifetime เอง

ตัวอย่าง: เมื่อต้องใส่ Lifetime

#![allow(unused)]
fn main() {
// ✅ Elision works - Rule 2
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// ❌ Elision fails - must annotate
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
}

Lifetime ใน Structs

Struct ที่มี references ต้องมี lifetime annotation:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();

    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };

    println!("{}", excerpt.part);
}
// excerpt ต้องไม่อยู่นานกว่า novel

Methods on Structs with Lifetimes

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    // Rule 3 applies: return lifetime = self lifetime
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention: {}", announcement);
        self.part
    }
}

’static Lifetime

'static หมายถึง reference อยู่ได้ตลอดโปรแกรม:

#![allow(unused)]
fn main() {
let s: &'static str = "I have a static lifetime.";
}

String literals ทั้งหมดมี 'static lifetime เพราะเก็บใน binary

ระวัง!

อย่าใช้ 'static เพื่อ “แก้” lifetime errors โดยไม่เข้าใจ:

#![allow(unused)]
fn main() {
// ❌ Bad: ใช้ 'static แบบผิดๆ
fn get_str() -> &'static str {
    let s = String::from("hello");
    &s  // ❌ s จะถูก drop!
}

// ✅ Good: return owned String
fn get_str_good() -> String {
    String::from("hello")
}
}

Multiple Lifetimes

บางครั้งต้องใช้หลาย lifetimes:

#![allow(unused)]
fn main() {
fn longest_with_announcement<'a, 'b>(
    x: &'a str,
    y: &'a str,
    ann: &'b str,
) -> &'a str {
    println!("Announcement: {}", ann);
    if x.len() > y.len() { x } else { y }
}
}

Lifetime Bounds

ใช้กับ generics:

#![allow(unused)]
fn main() {
fn longest_with_trait<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
where
    T: std::fmt::Display,
{
    println!("Announcement: {}", ann);
    if x.len() > y.len() { x } else { y }
}
}

ลองทำดู! 🎯

1. เขียน struct ที่มี lifetime annotation
2. เขียน function ที่ต้องใส่ lifetime
3. ลองตัด lifetime ออกและดู compiler error

สรุป

กฎ Elision

1. แต่ละ input ได้ lifetime ตัวเอง
2. input เดียว → ใช้กับ output
3. &self → output ใช้ lifetime ของ self

👉 ต่อไป: บทที่ 11: Modules & Packages

บทที่ 11: Modules & Packages

จัดระเบียบโค้ดเป็น modules และ packages

สิ่งที่จะได้เรียนรู้

👉 Packages & Crates

Packages & Crates

Crate

Crate คือหน่วยการ compile ที่เล็กที่สุด มี 2 แบบ:

• Binary crate - โปรแกรมที่รันได้ (มี main)
• Library crate - โค้ดที่ใช้ร่วมกัน (ไม่มี main)

📦 Package Structure Visualization

+-------------------------------------------------------------------+
|                    Rust Package Hierarchy                         |
+-------------------------------------------------------------------+
|                                                                   |
|   Package (Cargo.toml)                                            |
|   +-- Binary Crate (src/main.rs)      <--- executable             |
|   |   +-- mod auth                                                |
|   |   +-- mod database                                            |
|   |   +-- mod routes                                              |
|   |                                                               |
|   +-- Library Crate (src/lib.rs)      <--- shared code            |
|       +-- pub mod models                                          |
|       +-- pub mod utils                                           |
|       +-- pub mod errors                                          |
|                                                                   |
+-------------------------------------------------------------------+
|   Dependencies (Cargo.toml)                                       |
|   +-- serde = "1.0"                   <--- External crates        |
|   +-- tokio = { version = "1", features = ["full"] }              |
|   +-- rand = "0.8"                                                |
|                                                                   |
+-------------------------------------------------------------------+

Package

Package = collection ของ crates พร้อม Cargo.toml

my-package/
├── Cargo.toml
├── src/
│   ├── main.rs      # binary crate root
│   └── lib.rs       # library crate root (optional)
└── src/bin/         # additional binaries
    └── another.rs

สร้าง Package

# Binary package
cargo new my-app

# Library package
cargo new my-lib --lib

Cargo.toml

[package]
name = "my-app"
version = "0.1.0"
edition = "2024"

[dependencies]
rand = "0.8"
serde = { version = "1.0", features = ["derive"] }

👉 ต่อไป: Modules

Modules

Modules จัดกลุ่มโค้ดและควบคุม privacy เป็นพื้นฐานของการจัดโครงสร้างโปรเจกต์ใน Rust

Module Tree

โปรเจกต์ Rust มีโครงสร้างเป็น tree:

นิยาม Module

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn seat_at_table() {} // private
    }

    mod serving {
        fn take_order() {}
        fn serve_order() {}
    }
}

fn main() {
    // เรียกใช้ public function
    front_of_house::hosting::add_to_waitlist();
}

pub Keyword

Default: ทุกอย่างเป็น private

mod my_module {
    pub fn public_function() {}  // ✅ เข้าถึงได้จากนอก
    fn private_function() {}     // ❌ private

    pub struct PublicStruct {
        pub name: String,        // ✅ field public
        age: u32,                // ❌ field private
    }

    pub enum PublicEnum {
        Variant1,  // ✅ variants ของ pub enum เป็น public
        Variant2,
    }
}

Visibility Modifiers

mod outer {
    pub(crate) fn crate_only() {}

    pub mod inner {
        pub(super) fn parent_only() {}

        pub(in crate::outer) fn outer_only() {}
    }
}

fn main() {
    outer::crate_only();      // ✅ OK - same crate
    // outer::inner::parent_only(); // ❌ Error - only visible to outer
}

ใช้ use

Basic use

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use front_of_house::hosting;

fn main() {
    hosting::add_to_waitlist();
}

Idiomatic use

// ✅ Good: use parent module สำหรับ functions
use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("key", "value");
}

// ✅ Good: use full path สำหรับ structs/enums
use std::collections::HashMap;
use std::io::Result;

use กับ as (alias)

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    Ok(())
}

fn function2() -> IoResult<()> {
    Ok(())
}

Re-exporting with pub use

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// Re-export ให้ผู้ใช้ library เข้าถึงได้ง่าย
pub use crate::front_of_house::hosting;

// ผู้ใช้ library เรียกได้แค่:
// use my_crate::hosting;
// hosting::add_to_waitlist();

Nested Paths

// แทนที่จะเขียน:
use std::cmp::Ordering;
use std::io;

// เขียนแบบนี้:
use std::{cmp::Ordering, io};

// หรือ:
use std::io::{self, Write};
// = use std::io และ use std::io::Write

Glob Operator

// นำเข้าทุกอย่างที่เป็น public
use std::collections::*;

fn main() {
    let mut map = HashMap::new();
    let mut set = HashSet::new();
}

คำเตือน: ใช้ * ระวัง เพราะไม่ชัดเจนว่า names มาจากไหน

ตัวอย่างจริง: Library Structure

// lib.rs
mod authentication;
mod database;
mod handlers;

pub use authentication::User;
pub use database::Connection;

pub mod api {
    pub use crate::handlers::*;
}

ผู้ใช้ library:

use my_lib::User;
use my_lib::Connection;
use my_lib::api::get_users;

Privacy Rules

1. Parent can’t see private children
2. Children can see private ancestors
3. Siblings can see each other

mod parent {
    fn parent_private() {}
    pub fn parent_public() {}

    mod child {
        fn child_func() {
            super::parent_private(); // ✅ Child can access parent's private
            super::parent_public();  // ✅
        }
    }

    mod sibling {
        fn call_child() {
            // super::child::child_func(); // ❌ Can't access sibling's private
        }
    }
}

ลองทำดู! 🎯

1. สร้าง module tree 3 ระดับ
2. ใช้ pub(crate) และ pub(super)
3. Re-export ด้วย pub use

สรุป

👉 ต่อไป: Paths

Paths

เข้าถึง items ใน module tree ด้วย paths

2 รูปแบบของ Path

Absolute Path

เริ่มจาก crate root ด้วย crate:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {
            println!("Adding to waitlist");
        }
    }
}

fn main() {
    // Absolute path - ชัดเจน ไม่กำกวม
    crate::front_of_house::hosting::add_to_waitlist();
}

Relative Path

เริ่มจาก module ปัจจุบัน:

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

fn main() {
    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

super Keyword

super = parent module (เหมือน .. ใน filesystem)

mod parent {
    fn parent_function() {
        println!("In parent");
    }

    pub mod child {
        pub fn call_parent() {
            // super ชี้ไปที่ parent module
            super::parent_function();
        }

        pub fn call_sibling() {
            // เรียก sibling module
            super::sibling::sibling_function();
        }
    }

    pub mod sibling {
        pub fn sibling_function() {
            println!("In sibling");
        }
    }
}

fn main() {
    parent::child::call_parent();
    parent::child::call_sibling();
}

self Keyword

self = current module

mod my_module {
    pub fn function_a() {
        println!("Function A");
    }

    pub fn function_b() {
        // ใช้ self เรียก function ใน module เดียวกัน
        self::function_a();

        // หรือเรียกตรงๆ ก็ได้
        function_a();
    }
}

ใช้ self กับ use

mod outer {
    pub mod inner {
        pub fn func() {}
    }

    pub fn use_inner() {
        // use self เพื่อนำเข้าจาก current module
        use self::inner::func;
        func();
    }
}

Path ใน use Statement

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        pub fn seat_at_table() {}
    }
}

// นำเข้า module
use crate::front_of_house::hosting;

// หรือนำเข้า function โดยตรง
use crate::front_of_house::hosting::add_to_waitlist;

fn main() {
    // เรียกผ่าน module
    hosting::add_to_waitlist();

    // หรือเรียกตรง
    add_to_waitlist();
}

เลือกใช้ Absolute vs Relative?

// ✅ Good: ถ้าย้าย main ไปที่อื่น ไม่ต้องแก้
crate::utils::helper();

// ⚠️ Might break: ถ้าย้าย function นี้ไปที่อื่น
utils::helper();

ตัวอย่างจริง

mod database {
    pub mod connection {
        pub fn connect() {
            println!("Connecting...");
        }
    }

    pub mod queries {
        use super::connection;  // parent's sibling

        pub fn execute() {
            connection::connect();
            println!("Executing query...");
        }
    }
}

mod handlers {
    use crate::database;  // absolute path

    pub fn handle_request() {
        database::queries::execute();
    }
}

fn main() {
    handlers::handle_request();
}

ลองทำดู! 🎯

1. สร้าง nested modules และใช้ super
2. ใช้ self ใน use statement
3. เปรียบเทียบ absolute และ relative paths

สรุป

Path Examples

crate::module::item        // absolute
module::item               // relative
self::item                 // current module
super::item                // parent module
super::super::item         // grandparent

👉 ต่อไป: แยกไฟล์

แยกไฟล์

จัดโครงสร้างโปรเจกต์ใหญ่ด้วยการแยก modules เป็นไฟล์

2 รูปแบบโครงสร้าง

รูปแบบ 1: ไฟล์เดียว

src/
├── main.rs
└── my_module.rs   ← mod my_module; จะหาที่นี่

รูปแบบ 2: โฟลเดอร์ + mod.rs

src/
├── main.rs
└── my_module/
    ├── mod.rs      ← mod my_module; จะหาที่นี่
    └── submodule.rs

ตัวอย่าง: โปรเจกต์จริง

โครงสร้าง

my_project/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── lib.rs
    ├── config.rs
    ├── database/
    │   ├── mod.rs
    │   ├── connection.rs
    │   └── queries.rs
    └── handlers/
        ├── mod.rs
        ├── users.rs
        └── posts.rs

src/lib.rs

// ประกาศ modules
pub mod config;
pub mod database;
pub mod handlers;

src/config.rs

pub struct Config {
    pub database_url: String,
    pub port: u16,
}

impl Config {
    pub fn new() -> Self {
        Config {
            database_url: String::from("postgres://localhost/mydb"),
            port: 3000,
        }
    }
}

src/database/mod.rs

// ประกาศ submodules
pub mod connection;
pub mod queries;

// Re-export items ที่ใช้บ่อย
pub use connection::DatabaseConnection;
pub use queries::Query;

src/database/connection.rs

pub struct DatabaseConnection {
    url: String,
    connected: bool,
}

impl DatabaseConnection {
    pub fn new(url: &str) -> Self {
        DatabaseConnection {
            url: url.to_string(),
            connected: false,
        }
    }

    pub fn connect(&mut self) {
        self.connected = true;
        println!("Connected to {}", self.url);
    }
}

src/database/queries.rs

use super::DatabaseConnection;

pub struct Query {
    sql: String,
}

impl Query {
    pub fn new(sql: &str) -> Self {
        Query { sql: sql.to_string() }
    }

    pub fn execute(&self, _conn: &DatabaseConnection) {
        println!("Executing: {}", self.sql);
    }
}

src/handlers/mod.rs

pub mod users;
pub mod posts;

src/main.rs

use my_project::{config::Config, database::DatabaseConnection};

fn main() {
    let config = Config::new();
    let mut db = DatabaseConnection::new(&config.database_url);
    db.connect();

    println!("Server starting on port {}", config.port);
}

Module Discovery Rules

Rust หา module ตามลำดับนี้:

1. Inline: mod name { ... } ใน file เดียวกัน
2. File: src/name.rs
3. Directory: src/name/mod.rs

// src/lib.rs
mod foo;        // หา src/foo.rs หรือ src/foo/mod.rs
mod bar;        // หา src/bar.rs หรือ src/bar/mod.rs

mod inline {    // inline module
    pub fn stuff() {}
}

2018+ Edition Style (แนะนำ)

แทนที่จะใช้ mod.rs ใช้ชื่อ folder:

src/
├── lib.rs
├── database.rs      ← แทน database/mod.rs
└── database/
    ├── connection.rs
    └── queries.rs
```text

```rust,ignore
// src/database.rs
pub mod connection;
pub mod queries;

Private vs Public Files

// src/lib.rs
mod private_module;      // private - ใช้ได้ใน crate นี้เท่านั้น
pub mod public_module;   // public - user ของ crate ใช้ได้

Workspace

สำหรับโปรเจกต์ใหญ่มาก:

my_workspace/
├── Cargo.toml           ← [workspace]
├── crates/
│   ├── core/
│   │   ├── Cargo.toml
│   │   └── src/lib.rs
│   ├── api/
│   │   ├── Cargo.toml
│   │   └── src/lib.rs
│   └── cli/
│       ├── Cargo.toml
│       └── src/main.rs
```text

```toml,ignore
# Cargo.toml (workspace root)
[workspace]
members = ["crates/*"]

ลองทำดู! 🎯

1. สร้างโปรเจกต์ที่มี 2-3 modules
2. แยก modules เป็นไฟล์
3. ใช้ pub use re-export

สรุปบทที่ 11

Best Practices

1. ใช้ 2018 style (ไม่ใช้ mod.rs)
2. pub use re-export items ที่สำคัญ
3. ใช้ workspace สำหรับโปรเจกต์ใหญ่

👉 ต่อไป: บทที่ 12: Testing

บทที่ 12: Testing

Rust มี testing framework ในตัว

สิ่งที่จะได้เรียนรู้

👉 Unit Tests

Unit Tests

Rust มี testing framework ในตัว ไม่ต้องติดตั้งเพิ่ม

🧪 Testing Pyramid in Rust

+-------------------------------------------------------------------+
|                    Testing Pyramid                                |
+-------------------------------------------------------------------+
|                                                                   |
|                           /\                                      |
|                          /  \                                     |
|                         / E2E\      <--- Slow, Expensive          |
|                        /------\                                   |
|                       /        \                                  |
|                      /Integration\ <--- tests/ directory          |
|                     /--------------\                              |
|                    /                \                             |
|                   /   Unit Tests     \ <--- Fast, Many            |
|                  /--------------------\     #[cfg(test)]          |
|                                                                   |
+-------------------------------------------------------------------+
|   Rust Test Commands:                                             |
|   * cargo test              --> Run all tests                     |
|   * cargo test --lib        --> Unit tests only                   |
|   * cargo test --test '*'   --> Integration tests                 |
|   * cargo test --doc        --> Doc tests                         |
+-------------------------------------------------------------------+

โครงสร้างพื้นฐาน

fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;  // นำเข้า items จาก parent module

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, 1), 0);
    }
}

รัน Tests

# รัน tests ทั้งหมด
cargo test

# รัน test เฉพาะชื่อ
cargo test test_add

# รัน tests ที่มีคำนี้
cargo test add

# รัน tests ใน module
cargo test tests::

Assertions

assert!

#[test]
fn test_assert() {
    assert!(true);
    assert!(1 + 1 == 2);

    // Custom error message
    assert!(4 > 2, "4 should be greater than 2");

    // กับ format arguments
    let x = 5;
    assert!(x > 0, "x should be positive, got {}", x);
}

assert_eq! และ assert_ne!

#[test]
fn test_equality() {
    assert_eq!(4, 2 + 2);
    assert_ne!(4, 5);

    // Custom message
    let result = 10;
    assert_eq!(result, 10, "Expected 10, got {}", result);
}

debug_assert!

เฉพาะ debug builds:

fn expensive_check(x: i32) -> bool {
    // expensive computation
    x > 0
}

fn process(x: i32) {
    debug_assert!(expensive_check(x), "x must be positive");
    // ใน release build, debug_assert! ถูกลบออก
}

ทดสอบ Panic

#[should_panic]

pub fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Cannot divide by zero!");
    }
    a / b
}

#[test]
#[should_panic]
fn test_divide_by_zero() {
    divide(10, 0);
}

// ระบุ expected message
#[test]
#[should_panic(expected = "Cannot divide by zero")]
fn test_divide_by_zero_message() {
    divide(10, 0);
}

ใช้ Result ใน Tests

#[test]
fn test_with_result() -> Result<(), String> {
    if 2 + 2 == 4 {
        Ok(())
    } else {
        Err(String::from("Math is broken"))
    }
}

// ใช้กับ ? operator
#[test]
fn test_file_operations() -> Result<(), std::io::Error> {
    let content = std::fs::read_to_string("test.txt")?;
    assert!(content.contains("expected"));
    Ok(())
}

Test Output Control

แสดง println! output

# ปกติ output จะถูกซ่อน
cargo test

# แสดง output
cargo test -- --show-output

# หรือ
cargo test -- --nocapture

ตัวอย่าง

#[test]
fn test_with_output() {
    println!("Setting up test...");
    let result = 2 + 2;
    println!("Result: {}", result);
    assert_eq!(result, 4);
    println!("Test passed!");
}

Control Test Execution

รันแบบ Single Thread

# ปกติ tests รันแบบ parallel
cargo test

# รันแบบ sequential
cargo test -- --test-threads=1

Ignore Tests

#[test]
#[ignore]
fn expensive_test() {
    // takes a long time
    std::thread::sleep(std::time::Duration::from_secs(60));
}

// รัน ignored tests
// cargo test -- --ignored

// รันทุก tests รวม ignored
// cargo test -- --include-ignored

Test Private Functions

ใน Rust ทดสอบ private functions ได้:

fn internal_adder(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_internal() {
        // ✅ เข้าถึง private function ได้
        assert_eq!(internal_adder(2, 2), 4);
    }
}

Doc Tests

ทดสอบ code ใน documentation:

#![allow(unused)]
fn main() {
/// Adds two numbers together.
///
/// # Examples
///
/// ```
/// let result = my_crate::add(2, 3);
/// assert_eq!(result, 5);
/// ```text
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
}

# Doc tests รันกับ cargo test
cargo test

# รันเฉพาะ doc tests
cargo test --doc

Test Filtering

# รัน tests ที่ชื่อขึ้นต้นด้วย 'test_'
cargo test test_

# รัน tests ใน specific module
cargo test tests::unit::

# รันเฉพาะ test เดียว
cargo test tests::test_add -- --exact

Test Organization Best Practices

// src/lib.rs

pub fn public_function() -> i32 {
    private_helper() + 1
}

fn private_helper() -> i32 {
    41
}

// Unit tests อยู่ในไฟล์เดียวกัน
#[cfg(test)]
mod tests {
    use super::*;

    mod public_api_tests {
        use super::*;

        #[test]
        fn test_public_function() {
            assert_eq!(public_function(), 42);
        }
    }

    mod internal_tests {
        use super::*;

        #[test]
        fn test_private_helper() {
            assert_eq!(private_helper(), 41);
        }
    }
}

ลองทำดู! 🎯

1. เขียน tests สำหรับ function ที่ควร panic
2. ใช้ #[ignore] และลองรัน cargo test -- --ignored
3. เขียน doc test ใน function documentation

สรุป

Cargo Test Flags

👉 ต่อไป: Integration Tests

Integration Tests

Integration tests ทดสอบ library จากมุมมองของ user ภายนอก

Unit Tests vs Integration Tests

โครงสร้างโปรเจกต์

my_library/
├── Cargo.toml
├── src/
│   └── lib.rs
└── tests/
    ├── common/
    │   └── mod.rs        ← shared test utilities
    ├── integration_test.rs
    └── another_test.rs

สร้าง Integration Test

src/lib.rs

#![allow(unused)]
fn main() {
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

pub struct Calculator {
    value: i32,
}

impl Calculator {
    pub fn new() -> Self {
        Calculator { value: 0 }
    }

    pub fn add(&mut self, n: i32) {
        self.value += n;
    }

    pub fn result(&self) -> i32 {
        self.value
    }
}
}

tests/integration_test.rs

use my_library::{add, multiply, Calculator};

#[test]
fn test_add() {
    assert_eq!(add(2, 3), 5);
    assert_eq!(add(-1, 1), 0);
    assert_eq!(add(0, 0), 0);
}

#[test]
fn test_multiply() {
    assert_eq!(multiply(2, 3), 6);
    assert_eq!(multiply(-2, 3), -6);
    assert_eq!(multiply(0, 100), 0);
}

#[test]
fn test_calculator_workflow() {
    let mut calc = Calculator::new();

    calc.add(5);
    calc.add(10);
    calc.add(-3);

    assert_eq!(calc.result(), 12);
}

Shared Test Code

tests/common/mod.rs

use my_library::Calculator;

pub fn setup_calculator_with_value(value: i32) -> Calculator {
    let mut calc = Calculator::new();
    calc.add(value);
    calc
}

pub fn assert_close(a: f64, b: f64, epsilon: f64) {
    assert!((a - b).abs() < epsilon,
            "Expected {} to be close to {}", a, b);
}

pub struct TestContext {
    pub name: String,
    pub created_at: std::time::Instant,
}

impl TestContext {
    pub fn new(name: &str) -> Self {
        println!("Setting up test: {}", name);
        TestContext {
            name: name.to_string(),
            created_at: std::time::Instant::now(),
        }
    }
}

impl Drop for TestContext {
    fn drop(&mut self) {
        println!("Tearing down test: {} (took {:?})",
                 self.name,
                 self.created_at.elapsed());
    }
}

ใช้ Shared Code

// tests/integration_test.rs
mod common;

use my_library::Calculator;

#[test]
fn test_with_setup() {
    let _ctx = common::TestContext::new("calculator_test");

    let calc = common::setup_calculator_with_value(100);
    assert_eq!(calc.result(), 100);
}

รัน Integration Tests

# รันทุก tests (unit + integration)
cargo test

# รันเฉพาะ integration tests
cargo test --test integration_test

# รันเฉพาะ test เดียว
cargo test --test integration_test test_add

# รันทุก integration test files
cargo test --test '*'

Binary Crates

สำคัญ: Integration tests ใช้ได้กับ library crates เท่านั้น

ถ้ามีแค่ main.rs (binary crate):

// src/main.rs
fn main() {
    let result = add(2, 3);
    println!("{}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

ทางแก้: แยก logic ไปไว้ใน lib.rs:

// src/lib.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// src/main.rs
use my_crate::add;

fn main() {
    println!("{}", add(2, 3));
}

หลาย Test Files

// tests/math_tests.rs
use my_library::{add, multiply};

#[test]
fn test_math_operations() {
    assert_eq!(add(multiply(2, 3), 4), 10);
}

// tests/calculator_tests.rs
use my_library::Calculator;

#[test]
fn test_calculator_chain() {
    let mut calc = Calculator::new();
    calc.add(1);
    calc.add(2);
    calc.add(3);
    assert_eq!(calc.result(), 6);
}

Async Integration Tests

// tests/async_test.rs

#[tokio::test]
async fn test_async_function() {
    let result = my_library::async_fetch().await;
    assert!(result.is_ok());
}

ลองทำดู! 🎯

1. สร้าง tests/ folder และ integration test
2. สร้าง shared utilities ใน tests/common/mod.rs
3. รันเฉพาะ integration tests ด้วย --test

สรุป

File Structure

tests/
├── common/mod.rs     ← shared code (NOT a test)
├── test_a.rs         ← first test file
└── test_b.rs         ← second test file

👉 ต่อไป: จัดระเบียบ Tests

จัดระเบียบ Tests

วิธีจัดระเบียบ tests ให้ maintain ง่าย

#[cfg(test)]

Compile test code เฉพาะ เมื่อรัน cargo test:

#![allow(unused)]
fn main() {
// Production code
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Test code - ไม่รวมใน production build
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}
}

ทำไมต้องใช้?

• ลดขนาด binary
• ไม่ compile test dependencies
• code ที่ใช้แค่ test ไม่เข้าไปใน production

#[ignore] - ข้าม Tests

#[test]
fn fast_test() {
    assert!(true);
}

#[test]
#[ignore = "takes too long"]
fn slow_test() {
    std::thread::sleep(std::time::Duration::from_secs(10));
    assert!(true);
}

#[test]
#[ignore = "requires database"]
fn db_test() {
    // needs database connection
}

รัน Ignored Tests

# รันเฉพาะ tests ปกติ (ข้าม ignored)
cargo test

# รันเฉพาะ ignored tests
cargo test -- --ignored

# รันทั้งหมด (รวม ignored)
cargo test -- --include-ignored

Test Attributes รวม

#[test]
fn normal_test() {}

#[test]
#[ignore]
fn ignored_test() {}

#[test]
#[should_panic]
fn expected_panic() {
    panic!("This should happen");
}

#[test]
#[should_panic(expected = "specific message")]
fn expected_specific_panic() {
    panic!("specific message here");
}

Controlling Test Output

# แสดง println! output (ปกติซ่อน)
cargo test -- --show-output

# รัน tests แบบ sequential (ไม่ parallel)
cargo test -- --test-threads=1

# รัน test ที่ชื่อตรง
cargo test --exact test_name

# รัน tests ที่มีคำนี้ในชื่อ
cargo test add

Test Module Organization

Pattern 1: Tests ใต้ function

#![allow(unused)]
fn main() {
pub fn calculate(x: i32) -> i32 {
    x * 2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_calculate() {
        assert_eq!(calculate(5), 10);
    }
}
}

Pattern 2: Test submodules

#![allow(unused)]
fn main() {
pub fn add(a: i32, b: i32) -> i32 { a + b }
pub fn sub(a: i32, b: i32) -> i32 { a - b }

#[cfg(test)]
mod tests {
    use super::*;

    mod add_tests {
        use super::*;

        #[test]
        fn test_positive() {
            assert_eq!(add(2, 3), 5);
        }

        #[test]
        fn test_negative() {
            assert_eq!(add(-2, -3), -5);
        }
    }

    mod sub_tests {
        use super::*;

        #[test]
        fn test_basic() {
            assert_eq!(sub(5, 3), 2);
        }
    }
}
}

Test Helper Functions

#![allow(unused)]
fn main() {
#[cfg(test)]
mod tests {
    use super::*;

    // Helper - ไม่ใช่ test
    fn create_test_data() -> Vec<i32> {
        vec![1, 2, 3, 4, 5]
    }

    fn assert_even(n: i32) {
        assert!(n % 2 == 0, "{} is not even", n);
    }

    #[test]
    fn test_with_helpers() {
        let data = create_test_data();
        let sum: i32 = data.iter().sum();
        assert_even(sum); // ไม่ผ่าน เพราะ 15 ไม่ใช่เลขคู่
    }
}
}

Doc Tests

Comments ที่มี code examples จะถูก test:

#![allow(unused)]
fn main() {
/// Adds two numbers together.
///
/// # Examples
///
/// ```
/// let result = my_lib::add(2, 3);
/// assert_eq!(result, 5);
/// ```text
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// # Panics
///
/// Panics if divisor is zero.
///
/// ```should_panic
/// my_lib::divide(10, 0);
/// ```text
pub fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Division by zero");
    }
    a / b
}

/// Code that shouldn't compile:
///
/// ```compile_fail
/// let x: i32 = "not a number";
/// ```text
pub fn example() {}
}

Run Doc Tests

# รันเฉพาะ doc tests
cargo test --doc

Test Fixtures และ Setup

use std::fs;
use std::io::Write;

struct TestFile {
    path: String,
}

impl TestFile {
    fn new(name: &str, content: &str) -> Self {
        let path = format!("/tmp/test_{}", name);
        let mut file = fs::File::create(&path).unwrap();
        file.write_all(content.as_bytes()).unwrap();
        TestFile { path }
    }
}

impl Drop for TestFile {
    fn drop(&mut self) {
        fs::remove_file(&self.path).ok();
    }
}

#[test]
fn test_with_fixture() {
    let file = TestFile::new("example.txt", "Hello, World!");

    let content = fs::read_to_string(&file.path).unwrap();
    assert_eq!(content, "Hello, World!");
} // file ถูก cleanup อัตโนมัติ

ลองทำดู! 🎯

1. ใช้ #[ignore] กับ slow tests
2. สร้าง test helper functions
3. เขียน doc tests

สรุปบทที่ 12

Cargo Commands

Test Organization Tips

1. ใช้ #[cfg(test)] สำหรับ unit tests
2. แยก integration tests ไปไว้ใน tests/
3. ใช้ #[ignore] สำหรับ slow/flaky tests
4. เขียน doc tests สำหรับ public API

👉 ต่อไป: บทที่ 13: Iterators & Closures

บทที่ 13: Iterators & Closures

สิ่งที่จะได้เรียนรู้

👉 Closures

Closures

Closures คือ anonymous functions ที่สามารถ capture ค่าจาก environment รอบข้าง

Syntax พื้นฐาน

fn main() {
    // Closure พื้นฐาน
    let add_one = |x| x + 1;
    println!("{}", add_one(5));  // 6

    // กับ type annotations
    let add_two = |x: i32| -> i32 { x + 2 };
    println!("{}", add_two(5));  // 7

    // หลาย parameters
    let add = |a, b| a + b;
    println!("{}", add(2, 3));  // 5

    // ไม่มี parameters
    let say_hi = || println!("Hi!");
    say_hi();

    // Multi-line closure
    let calculate = |x: i32, y: i32| {
        let sum = x + y;
        let product = x * y;
        sum + product
    };
    println!("{}", calculate(3, 4));  // 7 + 12 = 19
}

Closure vs Function

#![allow(unused)]
fn main() {
fn add_one_fn(x: i32) -> i32 { x + 1 }
let add_one_closure = |x: i32| x + 1;

// ทั้งสองใช้เหมือนกัน
println!("{}", add_one_fn(5));       // 6
println!("{}", add_one_closure(5));  // 6
}

Capture Environment

Closures สามารถ “จับ” ค่าจากภายนอกได้:

fn main() {
    let x = 4;
    let multiplier = 3;

    // capture x และ multiplier
    let calculate = |y| x + y * multiplier;

    println!("{}", calculate(2));  // 4 + 2*3 = 10

    // x และ multiplier ยังใช้ได้ (ถูก borrow)
    println!("x = {}, multiplier = {}", x, multiplier);
}

3 Capture Modes

Rust มี 3 วิธีที่ closure capture ค่า:

1. Fn - Borrow (&T)

fn main() {
    let list = vec![1, 2, 3];

    // Fn: borrow list
    let print_list = || println!("{:?}", list);

    print_list();
    print_list();  // เรียกได้หลายครั้ง

    println!("Still valid: {:?}", list);  // ยังใช้ได้
}

2. FnMut - Mutable Borrow (&mut T)

fn main() {
    let mut count = 0;

    // FnMut: mutable borrow count
    let mut increment = || {
        count += 1;
        println!("Count: {}", count);
    };

    increment();  // Count: 1
    increment();  // Count: 2
    increment();  // Count: 3

    println!("Final: {}", count);  // 3
}

3. FnOnce - Move Ownership (T)

fn main() {
    let message = String::from("Hello");

    // FnOnce: move ownership
    let consume = move || {
        println!("{}", message);
        // message ถูก drop เมื่อ closure จบ
    };

    consume();
    // consume();  // ❌ Error: ใช้ได้แค่ครั้งเดียว

    // println!("{}", message);  // ❌ message ถูก move ไปแล้ว
}

move Keyword

บังคับให้ closure เป็นเจ้าของค่า:

fn main() {
    let name = String::from("Alice");

    // Without move: borrow
    let greet1 = || println!("Hello, {}!", name);
    greet1();
    println!("Name still valid: {}", name);

    // With move: take ownership
    let greet2 = move || println!("Hello, {}!", name);
    greet2();
    // println!("{}", name);  // ❌ name moved
}

ใช้ move กับ Threads

use std::thread;

fn main() {
    let data = vec![1, 2, 3];

    // ต้อง move เพราะ thread อาจอยู่นานกว่า main
    let handle = thread::spawn(move || {
        println!("Data in thread: {:?}", data);
    });

    handle.join().unwrap();
}

Closures as Parameters

ใช้ Trait Bounds

fn apply<F>(f: F)
where
    F: FnOnce(),
{
    f();
}

fn apply_twice<F>(mut f: F)
where
    F: FnMut(),
{
    f();
    f();
}

fn apply_many<F>(f: F, times: u32)
where
    F: Fn(),
{
    for _ in 0..times {
        f();
    }
}

fn main() {
    apply(|| println!("Called once!"));
    apply_twice(|| println!("Called!"));
    apply_many(|| println!("Hello!"), 3);
}

Trait Hierarchy

FnOnce  (ทุก closure เป็น FnOnce)
  ↓
FnMut   (ถ้าไม่ move ownership)
  ↓
Fn      (ถ้าไม่ mutate)

Closures as Return Values

fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn main() {
    let add_5 = make_adder(5);
    let add_10 = make_adder(10);

    println!("{}", add_5(3));   // 8
    println!("{}", add_10(3));  // 13
}

ตัวอย่างจริง: Map และ Filter

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // map กับ closure
    let doubled: Vec<i32> = numbers
        .iter()
        .map(|x| x * 2)
        .collect();
    println!("Doubled: {:?}", doubled);  // [2, 4, 6, 8, 10]

    // filter กับ closure
    let evens: Vec<&i32> = numbers
        .iter()
        .filter(|x| *x % 2 == 0)
        .collect();
    println!("Evens: {:?}", evens);  // [2, 4]

    // Combined
    let sum_of_squares: i32 = numbers
        .iter()
        .map(|x| x * x)
        .filter(|x| x % 2 == 0)
        .sum();
    println!("Sum of even squares: {}", sum_of_squares);  // 4 + 16 = 20
}

ลองทำดู! 🎯

1. สร้าง closure ที่ capture mutable variable และเพิ่มค่า
2. สร้าง function ที่รับ closure เป็น parameter
3. ใช้ move กับ thread::spawn

สรุป

👉 ต่อไป: Iterators

Iterators

Iterator ประมวลผล collection ทีละ item แบบ lazy (ไม่ทำจนกว่าจะต้องใช้)

🔗 Iterator Chain Visualization

Iterator Trait

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // ... มี methods อื่นๆ อีกมากที่ได้มาฟรี
}

ทุกครั้งที่เรียก next():

• Some(item) - ได้ item ถัดไป
• None - หมดแล้ว

Basic Usage

fn main() {
    let v = vec![1, 2, 3];

    // สร้าง iterator
    let mut iter = v.iter();

    // เรียก next() ทีละครั้ง
    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next(), Some(&3));
    assert_eq!(iter.next(), None);  // หมดแล้ว
    assert_eq!(iter.next(), None);  // ยังคง None
}

3 วิธีสร้าง Iterator

1. iter() - Borrow (&T)

fn main() {
    let v = vec![1, 2, 3];

    for x in v.iter() {
        println!("{}", x);  // x is &i32
    }

    // v ยังใช้ได้
    println!("Still valid: {:?}", v);
}

2. iter_mut() - Mutable Borrow (&mut T)

fn main() {
    let mut v = vec![1, 2, 3];

    for x in v.iter_mut() {
        *x *= 2;  // แก้ไขค่าได้
    }

    println!("{:?}", v);  // [2, 4, 6]
}

3. into_iter() - Take Ownership (T)

fn main() {
    let v = vec![String::from("a"), String::from("b")];

    for s in v.into_iter() {
        println!("{}", s);  // s is String (owned)
    }

    // println!("{:?}", v);  // ❌ v ถูก move ไปแล้ว
}

เปรียบเทียบ

for Loop กับ Iterator

fn main() {
    let v = vec![1, 2, 3];

    // ทั้งสองเหมือนกัน:

    // 1. for loop (syntactic sugar)
    for x in &v {
        println!("{}", x);
    }

    // 2. Explicit iterator
    let mut iter = v.iter();
    while let Some(x) = iter.next() {
        println!("{}", x);
    }
}

Lazy Evaluation

Iterator ไม่ทำอะไรจนกว่าจะ “consume”:

fn main() {
    let v = vec![1, 2, 3];

    // ยังไม่ทำอะไร! (lazy)
    let iter = v.iter().map(|x| {
        println!("Processing {}", x);
        x * 2
    });

    println!("Iterator created, nothing printed yet...");

    // consume iterator
    let result: Vec<_> = iter.collect();
    // NOW it prints "Processing 1, 2, 3"

    println!("Result: {:?}", result);
}

Range as Iterator

fn main() {
    // Range เป็น iterator
    for i in 0..5 {
        println!("{}", i);  // 0, 1, 2, 3, 4
    }

    // Inclusive range
    for i in 0..=5 {
        println!("{}", i);  // 0, 1, 2, 3, 4, 5
    }

    // Use with methods
    let sum: i32 = (1..=100).sum();
    println!("Sum 1-100: {}", sum);  // 5050
}

Common Iterators

fn main() {
    // chars() - iterate characters
    for c in "hello".chars() {
        println!("{}", c);
    }

    // bytes() - iterate bytes
    for b in "hello".bytes() {
        println!("{}", b);
    }

    // lines() - iterate lines
    let text = "line1\nline2\nline3";
    for line in text.lines() {
        println!("{}", line);
    }

    // enumerate() - with index
    let v = vec!["a", "b", "c"];
    for (i, x) in v.iter().enumerate() {
        println!("{}: {}", i, x);
    }
}

Infinite Iterators

fn main() {
    // repeat - ซ้ำค่าเดิมตลอด
    let threes: Vec<i32> = std::iter::repeat(3).take(5).collect();
    println!("{:?}", threes);  // [3, 3, 3, 3, 3]

    // cycle - วนซ้ำ
    let cycle: Vec<i32> = vec![1, 2].into_iter().cycle().take(6).collect();
    println!("{:?}", cycle);  // [1, 2, 1, 2, 1, 2]
}

ลองทำดู! 🎯

1. ใช้ iter(), iter_mut(), into_iter() ดูความแตกต่าง
2. สร้าง range iterator และ sum
3. ใช้ enumerate() กับ vector

สรุป

👉 ต่อไป: Iterator Methods

Iterator Methods

Methods ของ Iterator แบ่งเป็น 2 ประเภท: Adapters และ Consumers

Adapters (แปลง Iterator)

Adapters รับ iterator แล้ว return iterator ใหม่:

map - แปลงค่า

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let doubled: Vec<i32> = v.iter()
        .map(|x| x * 2)
        .collect();

    println!("{:?}", doubled);  // [2, 4, 6, 8, 10]
}

filter - เลือกเฉพาะที่ต้องการ

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];

    let evens: Vec<&i32> = v.iter()
        .filter(|x| *x % 2 == 0)
        .collect();

    println!("{:?}", evens);  // [2, 4, 6]
}

filter_map - filter + map รวมกัน

fn main() {
    let strings = vec!["1", "two", "3", "four", "5"];

    let numbers: Vec<i32> = strings.iter()
        .filter_map(|s| s.parse().ok())  // parse เฉพาะที่ได้
        .collect();

    println!("{:?}", numbers);  // [1, 3, 5]
}

enumerate - เพิ่ม index

fn main() {
    let v = vec!["a", "b", "c"];

    for (index, value) in v.iter().enumerate() {
        println!("{}: {}", index, value);
    }
    // 0: a
    // 1: b
    // 2: c
}

zip - จับคู่ 2 iterators

fn main() {
    let names = vec!["Alice", "Bob", "Charlie"];
    let scores = vec![95, 87, 92];

    for (name, score) in names.iter().zip(scores.iter()) {
        println!("{}: {}", name, score);
    }
    // Alice: 95
    // Bob: 87
    // Charlie: 92
}

take / skip

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // take: เอา n ตัวแรก
    let first_3: Vec<_> = v.iter().take(3).collect();
    println!("First 3: {:?}", first_3);  // [1, 2, 3]

    // skip: ข้าม n ตัวแรก
    let after_5: Vec<_> = v.iter().skip(5).collect();
    println!("After 5: {:?}", after_5);  // [6, 7, 8, 9, 10]

    // take_while / skip_while
    let small: Vec<_> = v.iter().take_while(|x| **x < 5).collect();
    println!("While < 5: {:?}", small);  // [1, 2, 3, 4]
}

flatten - แบน nested

fn main() {
    let nested = vec![vec![1, 2], vec![3, 4], vec![5]];

    let flat: Vec<i32> = nested.into_iter().flatten().collect();
    println!("{:?}", flat);  // [1, 2, 3, 4, 5]

    // flat_map = map + flatten
    let words = vec!["hello", "world"];
    let chars: Vec<char> = words.iter()
        .flat_map(|s| s.chars())
        .collect();
    println!("{:?}", chars);  // ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
}

chain - ต่อ 2 iterators

fn main() {
    let a = vec![1, 2, 3];
    let b = vec![4, 5, 6];

    let combined: Vec<_> = a.iter().chain(b.iter()).collect();
    println!("{:?}", combined);  // [1, 2, 3, 4, 5, 6]
}

rev - กลับลำดับ

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let reversed: Vec<_> = v.iter().rev().collect();
    println!("{:?}", reversed);  // [5, 4, 3, 2, 1]
}

Consumers (ใช้ Iterator)

Consumers รับ iterator และ return ค่า (ไม่ใช่ iterator):

collect - รวบรวมเป็น collection

fn main() {
    let v: Vec<i32> = (1..=5).collect();
    let set: std::collections::HashSet<_> = (1..=5).collect();

    println!("Vec: {:?}", v);    // [1, 2, 3, 4, 5]
    println!("Set: {:?}", set);  // {1, 2, 3, 4, 5}
}

sum / product

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    let total: i32 = numbers.iter().sum();
    println!("Sum: {}", total);  // 15

    let product: i32 = numbers.iter().product();
    println!("Product: {}", product);  // 120
}

fold - รวมค่าแบบ custom

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // fold(initial, |accumulator, item| new_accumulator)
    let sum = numbers.iter().fold(0, |acc, x| acc + x);
    println!("Sum: {}", sum);  // 15

    // ใช้ fold สร้าง string
    let s = numbers.iter().fold(String::new(), |acc, x| {
        if acc.is_empty() {
            x.to_string()
        } else {
            format!("{}, {}", acc, x)
        }
    });
    println!("String: {}", s);  // "1, 2, 3, 4, 5"
}

reduce - เหมือน fold แต่ไม่มี initial

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    let max = numbers.iter().reduce(|a, b| if a > b { a } else { b });
    println!("Max: {:?}", max);  // Some(5)
}

count / min / max

fn main() {
    let v = vec![3, 1, 4, 1, 5, 9, 2, 6];

    println!("Count: {}", v.iter().count());      // 8
    println!("Min: {:?}", v.iter().min());        // Some(1)
    println!("Max: {:?}", v.iter().max());        // Some(9)
}

find / position

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    // find - หาค่าแรกที่ตรง
    let first_even = v.iter().find(|x| *x % 2 == 0);
    println!("First even: {:?}", first_even);  // Some(2)

    // position - หา index
    let pos = v.iter().position(|x| *x == 3);
    println!("Position of 3: {:?}", pos);  // Some(2)
}

any / all

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let has_even = v.iter().any(|x| x % 2 == 0);
    println!("Has even: {}", has_even);  // true

    let all_positive = v.iter().all(|x| *x > 0);
    println!("All positive: {}", all_positive);  // true
}

for_each - side effects

fn main() {
    let v = vec![1, 2, 3];

    v.iter().for_each(|x| println!("Value: {}", x));
}

Chaining (ต่อเชื่อม)

fn main() {
    let data = vec!["1", "two", "3", "four", "5", "six"];

    let result: i32 = data.iter()
        .filter_map(|s| s.parse::<i32>().ok())  // parse เฉพาะตัวเลข
        .filter(|n| n % 2 == 1)                  // เอาเฉพาะเลขคี่
        .map(|n| n * n)                          // ยกกำลังสอง
        .sum();                                   // รวม

    println!("Sum of odd squares: {}", result);  // 1 + 9 + 25 = 35
}

ลองทำดู! 🎯

1. ใช้ map และ filter chain กัน
2. ใช้ enumerate และ zip
3. ใช้ fold หาค่า max เอง

สรุป

Adapters (return Iterator)

Consumers (return Value)

👉 ต่อไป: Custom Iterators

Custom Iterators

สร้าง iterator ของตัวเอง โดย implement Iterator trait

Implementation พื้นฐาน

struct Counter {
    count: u32,
    max: u32,
}

impl Counter {
    fn new(max: u32) -> Counter {
        Counter { count: 0, max }
    }
}

impl Iterator for Counter {
    type Item = u32;  // ระบุ type ที่จะ return

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None  // หมดแล้ว
        }
    }
}

fn main() {
    let counter = Counter::new(5);

    for n in counter {
        println!("{}", n);
    }
    // Output: 1, 2, 3, 4, 5
}

ใช้ Iterator Methods ได้ฟรี

เมื่อ implement next() ได้ Iterator methods ทั้งหมดมาฟรี:

fn main() {
    // sum
    let sum: u32 = Counter::new(5).sum();
    println!("Sum: {}", sum);  // 15

    // filter
    let evens: Vec<u32> = Counter::new(10)
        .filter(|x| x % 2 == 0)
        .collect();
    println!("Evens: {:?}", evens);  // [2, 4, 6, 8, 10]

    // map
    let squared: Vec<u32> = Counter::new(5)
        .map(|x| x * x)
        .collect();
    println!("Squared: {:?}", squared);  // [1, 4, 9, 16, 25]

    // chain กัน
    let result: u32 = Counter::new(10)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .sum();
    println!("Sum of even squares: {}", result);  // 220
}

ตัวอย่าง: Fibonacci Iterator

struct Fibonacci {
    curr: u64,
    next: u64,
}

impl Fibonacci {
    fn new() -> Fibonacci {
        Fibonacci { curr: 0, next: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u64;

    fn next(&mut self) -> Option<Self::Item> {
        let result = self.curr;

        self.curr = self.next;
        self.next = result + self.next;

        Some(result)  // Infinite iterator!
    }
}

fn main() {
    // Take first 10 Fibonacci numbers
    let fibs: Vec<u64> = Fibonacci::new().take(10).collect();
    println!("{:?}", fibs);
    // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

    // Find first Fibonacci > 100
    let first_over_100 = Fibonacci::new()
        .find(|&x| x > 100);
    println!("First > 100: {:?}", first_over_100);  // Some(144)
}

IntoIterator Trait

ทำให้ใช้กับ for loop ได้:

struct MyCollection {
    items: Vec<i32>,
}

impl IntoIterator for MyCollection {
    type Item = i32;
    type IntoIter = std::vec::IntoIter<i32>;

    fn into_iter(self) -> Self::IntoIter {
        self.items.into_iter()
    }
}

// สำหรับ reference
impl<'a> IntoIterator for &'a MyCollection {
    type Item = &'a i32;
    type IntoIter = std::slice::Iter<'a, i32>;

    fn into_iter(self) -> Self::IntoIter {
        self.items.iter()
    }
}

fn main() {
    let collection = MyCollection { items: vec![1, 2, 3] };

    // ใช้กับ for loop ได้
    for item in &collection {
        println!("{}", item);
    }

    // ยัง borrow ได้
    println!("Length: {}", collection.items.len());
}

DoubleEndedIterator

ทำให้ rev() ใช้ได้:

struct Range {
    start: i32,
    end: i32,
}

impl Range {
    fn new(start: i32, end: i32) -> Range {
        Range { start, end }
    }
}

impl Iterator for Range {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start < self.end {
            let result = self.start;
            self.start += 1;
            Some(result)
        } else {
            None
        }
    }
}

impl DoubleEndedIterator for Range {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.start < self.end {
            self.end -= 1;
            Some(self.end)
        } else {
            None
        }
    }
}

fn main() {
    // Forward
    let forward: Vec<i32> = Range::new(1, 5).collect();
    println!("Forward: {:?}", forward);  // [1, 2, 3, 4]

    // Reverse
    let backward: Vec<i32> = Range::new(1, 5).rev().collect();
    println!("Backward: {:?}", backward);  // [4, 3, 2, 1]
}

ExactSizeIterator

ถ้ารู้ขนาด:

impl ExactSizeIterator for Counter {
    fn len(&self) -> usize {
        (self.max - self.count) as usize
    }
}

fn main() {
    let counter = Counter::new(10);
    println!("Size: {}", counter.len());  // 10
}

ตัวอย่างจริง: Lines Iterator

struct Lines<'a> {
    remaining: &'a str,
}

impl<'a> Lines<'a> {
    fn new(s: &'a str) -> Lines<'a> {
        Lines { remaining: s }
    }
}

impl<'a> Iterator for Lines<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<Self::Item> {
        if self.remaining.is_empty() {
            return None;
        }

        match self.remaining.find('\n') {
            Some(pos) => {
                let line = &self.remaining[..pos];
                self.remaining = &self.remaining[pos + 1..];
                Some(line)
            }
            None => {
                let line = self.remaining;
                self.remaining = "";
                Some(line)
            }
        }
    }
}

fn main() {
    let text = "line1\nline2\nline3";

    for line in Lines::new(text) {
        println!("Line: {}", line);
    }
}

ลองทำดู! 🎯

1. สร้าง iterator ที่นับถอยหลัง
2. สร้าง Fibonacci iterator และ take(20)
3. Implement IntoIterator สำหรับ custom struct

สรุปบทที่ 13

Key Points

• implement next() → ได้ methods ฟรี
• type Item ระบุ type ที่ return
• IntoIterator ทำให้ใช้กับ for ได้

👉 ต่อไป: บทที่ 14: Smart Pointers

บทที่ 14: Smart Pointers

Smart pointers คือ structs ที่ทำตัวเหมือน pointers แต่มีความสามารถเพิ่มเติม

สิ่งที่จะได้เรียนรู้

👉 Box<T>

Box<T>

Box<T> เก็บข้อมูลบน heap แทน stack เป็น smart pointer ที่ง่ายที่สุด

เมื่อไหร่ใช้ Box?

1. Recursive types - type ที่มีตัวเองข้างใน
2. Large data - ย้ายข้อมูลใหญ่ไป heap
3. Trait objects - dynamic dispatch
4. Transfer ownership โดยไม่ copy

📦 Smart Pointer Comparison

การใช้งานพื้นฐาน

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);

    // Box implements Deref ใช้เหมือน reference
    let x = *b + 1;
    println!("x = {}", x);
}

Use Case 1: Recursive Types

ปัญหา: ขนาดไม่แน่นอน

#![allow(unused)]
fn main() {
// ❌ Error: recursive type has infinite size
enum List {
    Cons(i32, List),
    Nil,
}
}

Compiler ไม่รู้ว่า List ใหญ่เท่าไหร่

ทางแก้: ใช้ Box

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};

fn main() {
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil))))));

    // Print list
    print_list(&list);
}

fn print_list(list: &List) {
    match list {
        Cons(value, next) => {
            println!("{}", value);
            print_list(next);
        }
        Nil => println!("End"),
    }
}

ทำไมใช้ได้? Box มีขนาดคงที่ (pointer size) ไม่ว่าจะชี้ไปที่อะไร

Stack                    Heap
+-------------+         +-------------+
| Cons(1, ----+-------->| Cons(2, ----+--->...
+-------------+         +-------------+

Use Case 2: Trait Objects

trait Draw {
    fn draw(&self);
}

struct Circle { radius: f64 }
struct Square { side: f64 }

impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing circle with radius {}", self.radius);
    }
}

impl Draw for Square {
    fn draw(&self) {
        println!("Drawing square with side {}", self.side);
    }
}

fn main() {
    // Vec ของหลาย types ที่ implement Draw
    let shapes: Vec<Box<dyn Draw>> = vec![
        Box::new(Circle { radius: 5.0 }),
        Box::new(Square { side: 3.0 }),
    ];

    for shape in &shapes {
        shape.draw();
    }
}

Use Case 3: Large Data Transfer

fn main() {
    // Large array on stack
    let big_array = [0u8; 1_000_000]; // 1MB on stack!

    // Move to heap with Box
    let boxed_array = Box::new([0u8; 1_000_000]); // 1MB on heap

    // Now ownership transfer is cheap (just move pointer)
    let another_owner = boxed_array; // Fast move!
}

Deref Trait

Box implements Deref ทำให้ใช้งานเหมือน reference:

use std::ops::Deref;

fn main() {
    let x = 5;
    let y = Box::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y); // Deref แปลง Box<T> -> T

    // Deref coercion
    let s = Box::new(String::from("hello"));
    hello(&s); // Box<String> -> &String -> &str
}

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

Deref Coercion

Rust แปลง types อัตโนมัติผ่าน Deref chain:

// Box<String> -> String -> str
// &Box<String> -> &String -> &str

fn main() {
    let b = Box::new(String::from("Rust"));

    // ทั้งหมดนี้ใช้ได้เหมือนกัน
    greet(&b);           // &Box<String>
    greet(&*b);          // &String
    greet(&(*b)[..]);    // &str
}

fn greet(s: &str) {
    println!("Hello, {}!", s);
}

Drop Trait

Box จะ drop ทั้ง pointer และ data บน heap เมื่อออกจาก scope:

fn main() {
    {
        let b = Box::new(String::from("hello"));
        println!("{}", b);
    } // b dropped here → String on heap is freed

    println!("Box is dropped!");
}

Custom Drop

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}
// Output:
// CustomSmartPointers created.
// Dropping CustomSmartPointer with data `other stuff`!
// Dropping CustomSmartPointer with data `my stuff`!

Drop Early with std::mem::drop

fn main() {
    let c = Box::new(String::from("hello"));

    println!("Before drop");
    drop(c);  // Drop early
    println!("After drop");

    // println!("{}", c); // ❌ Error: c was moved
}

เปรียบเทียบ Box กับ Stack

ลองทำดู! 🎯

1. สร้าง Binary Tree ด้วย Box
2. Implement trait object vector
3. ลอง drop Box ก่อนออกจาก scope

สรุป

👉 ต่อไป: Rc<T>

Rc<T>

Rc<T> (Reference Counted) ให้หลาย owners ได้ ใช้เมื่อต้องการ share ownership

เมื่อไหร่ใช้ Rc?

ปกติ Rust มี owner เดียว แต่บางครั้งต้องการหลาย owners:

      +-----+
      |  a  |
      +--+--+
         |
      +--v--+
      |  5  |<-- want b and c to share this too
      +-----+
         ^
    +----+----+
 +--+--+   +--+--+
 |  b  |   |  c  |
 +-----+   +-----+

การใช้งาน

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("hello"));

    println!("Count after a: {}", Rc::strong_count(&a)); // 1

    let b = Rc::clone(&a);  // เพิ่ม reference count
    println!("Count after b: {}", Rc::strong_count(&a)); // 2

    {
        let c = Rc::clone(&a);
        println!("Count in block: {}", Rc::strong_count(&a)); // 3
    } // c dropped, count -= 1

    println!("Count after block: {}", Rc::strong_count(&a)); // 2
}

หมายเหตุ: Rc::clone ไม่ copy data แค่เพิ่ม reference count

Rc::clone vs .clone()

use std::rc::Rc;

fn main() {
    let a = Rc::new(vec![1, 2, 3]);

    // ✅ Preferred: ชัดเจนว่าเพิ่ม reference count
    let b = Rc::clone(&a);

    // ✅ ก็ใช้ได้ แต่อาจสับสนกับ deep clone
    let c = a.clone();

    // Both b and c point to the same data
}

Shared List Example

use std::rc::Rc;

enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use List::{Cons, Nil};

fn main() {
    // a = [5, 10, Nil]
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("Count after a: {}", Rc::strong_count(&a)); // 1

    // b = [3, -> a]
    let b = Cons(3, Rc::clone(&a));
    println!("Count after b: {}", Rc::strong_count(&a)); // 2

    // c = [4, -> a]
    let c = Cons(4, Rc::clone(&a));
    println!("Count after c: {}", Rc::strong_count(&a)); // 3

    // a ถูก share โดย b และ c
}

b: Cons(3, --+
             |     +-------------------------+
             +---->| a: Cons(5, Cons(10, Nil))|
             +---->|                         |
             |     +-------------------------+
c: Cons(4, --+

Rc<T> Properties

Rc กับ Methods

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("hello"));

    // Deref ใช้ methods ของ inner type ได้
    println!("Length: {}", a.len());
    println!("Uppercase: {}", a.to_uppercase());

    // Rc methods
    println!("Strong count: {}", Rc::strong_count(&a));

    // Get reference
    let s: &String = &a;
    println!("Ref: {}", s);
}

Rc::downgrade และ Weak

use std::rc::{Rc, Weak};

fn main() {
    let strong = Rc::new(5);
    let weak: Weak<i32> = Rc::downgrade(&strong);

    println!("Strong count: {}", Rc::strong_count(&strong)); // 1
    println!("Weak count: {}", Rc::weak_count(&strong));     // 1

    // Weak ต้อง upgrade เป็น Rc ก่อนใช้
    if let Some(value) = weak.upgrade() {
        println!("Value: {}", value);
    }

    drop(strong); // strong dropped

    // Weak ยัง upgrade ไม่ได้
    assert!(weak.upgrade().is_none());
}

Weak ใช้ป้องกัน reference cycles (ดูบท 04-weak.md)

ข้อจำกัดของ Rc

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);

    // ❌ Error: cannot borrow as mutable
    // *a += 1;

    // Rc ให้แค่ shared reference (&T)
    // ถ้าต้องการ mutate ใช้ร่วมกับ RefCell
}

Rc + RefCell Pattern

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    // Multiple owners + Interior mutability
    let value = Rc::new(RefCell::new(5));

    let a = Rc::clone(&value);
    let b = Rc::clone(&value);

    // ทั้ง a และ b สามารถ mutate ได้
    *a.borrow_mut() += 10;
    *b.borrow_mut() += 10;

    println!("Value: {}", value.borrow()); // 25
}

ลองทำดู! 🎯

1. สร้าง shared data ด้วย Rc
2. Print strong_count ขณะ clone และ drop
3. ลอง combine Rc กับ RefCell

สรุป

เมื่อไหร่ใช้

👉 ต่อไป: RefCell<T>

RefCell<T>

RefCell<T> ให้ interior mutability - mutate ข้อมูลแม้มี immutable references

ปัญหา: Borrowing Rules ตอน Compile

fn main() {
    let x = 5;

    // ❌ Error at compile time
    // let y = &mut x; // cannot borrow as mutable
}

บางครั้งต้องการ mutate แม้ interface เป็น immutable

RefCell Basics

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);

    // borrow() returns Ref<T> (like &T)
    println!("Value: {}", data.borrow());

    // borrow_mut() returns RefMut<T> (like &mut T)
    *data.borrow_mut() += 1;

    println!("Value: {}", data.borrow()); // 6
}

Compile-time vs Runtime

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);

    let borrow1 = data.borrow();
    let borrow2 = data.borrow(); // ✅ OK - multiple immutable borrows

    println!("{} {}", borrow1, borrow2);

    drop(borrow1);
    drop(borrow2);

    let mut_borrow = data.borrow_mut();
    // let another = data.borrow_mut(); // 💥 Panic at runtime!
}

Borrowing Rules (Runtime)

เหมือนกับ compile-time rules:

1. หลาย immutable borrows ได้
2. หนึ่ง mutable borrow เท่านั้น
3. ไม่มี mutable + immutable พร้อมกัน

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(vec![1, 2, 3]);

    // ✅ Multiple borrows (must be dropped before mut borrow)
    {
        let a = data.borrow();
        let b = data.borrow();
        println!("{:?} {:?}", a, b);
    }

    // ✅ Single mut borrow
    {
        let mut c = data.borrow_mut();
        c.push(4);
    }

    println!("{:?}", data.borrow());
}

try_borrow และ try_borrow_mut

ไม่ panic แต่ return Result:

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);

    let borrow = data.borrow();

    match data.try_borrow_mut() {
        Ok(mut value) => *value += 1,
        Err(_) => println!("Already borrowed!"),
    }
}

Use Case: Mock Objects

use std::cell::RefCell;

trait Messenger {
    fn send(&self, msg: &str);
}

struct MockMessenger {
    messages: RefCell<Vec<String>>,
}

impl MockMessenger {
    fn new() -> MockMessenger {
        MockMessenger {
            messages: RefCell::new(vec![]),
        }
    }
}

impl Messenger for MockMessenger {
    fn send(&self, msg: &str) {
        // &self is immutable, but we can still mutate!
        self.messages.borrow_mut().push(String::from(msg));
    }
}

fn main() {
    let messenger = MockMessenger::new();
    messenger.send("Hello");
    messenger.send("World");

    assert_eq!(messenger.messages.borrow().len(), 2);
}

Rc + RefCell = Multiple Owners + Mutability

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        children: RefCell::new(vec![]),
    });

    let branch = Rc::new(Node {
        value: 5,
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    // Add another child to branch
    branch.children.borrow_mut().push(Rc::new(Node {
        value: 7,
        children: RefCell::new(vec![]),
    }));

    println!("leaf: {:#?}", leaf);
    println!("branch: {:#?}", branch);
}

Common Pattern: Shared Mutable State

use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let counter = Rc::new(RefCell::new(0));

    let counter1 = Rc::clone(&counter);
    let counter2 = Rc::clone(&counter);

    *counter1.borrow_mut() += 1;
    *counter2.borrow_mut() += 1;
    *counter.borrow_mut() += 1;

    println!("Final count: {}", counter.borrow()); // 3
}

Cell<T> (simpler alternative)

สำหรับ Copy types:

use std::cell::Cell;

fn main() {
    let x = Cell::new(5);

    x.set(10);           // ไม่ต้อง borrow
    let value = x.get(); // Copy ออกมา

    println!("{}", value); // 10
}

ลองทำดู! 🎯

1. สร้าง struct ที่มี RefCell\<Vec\<String\>\>
2. Implement method ที่ modify Vec ผ่าน &self
3. ลอง borrow ผิด rule และดู panic

สรุป

เลือกใช้

👉 ต่อไป: Weak<T>

Weak<T>

Weak<T> เป็น reference ที่ไม่นับ ใช้ป้องกัน reference cycles (memory leak)

ปัญหา: Reference Cycle

เมื่อ Rc ชี้หากันเป็นวงกลม:

   +--------------------------+
   |                          |
   v                          |
+------+    strong    +------+|
| Node |<------------>| Node ||
|  A   |              |  B   ||
+------+              +------+|
   |                          |
   +--------------------------+

When A and B go out of scope:
- A has strong reference from B -> not dropped
- B has strong reference from A -> not dropped
-> Memory leak!

ทางออก: ใช้ Weak

use std::rc::{Rc, Weak};

// Weak ไม่นับ reference
// ถ้า strong count เป็น 0 → data ถูก drop
// แม้จะยังมี weak references อยู่

Rc::downgrade และ Weak::upgrade

use std::rc::{Rc, Weak};

fn main() {
    let strong = Rc::new(5);

    // สร้าง Weak จาก Rc
    let weak: Weak<i32> = Rc::downgrade(&strong);

    println!("Strong count: {}", Rc::strong_count(&strong));  // 1
    println!("Weak count: {}", Rc::weak_count(&strong));      // 1

    // Weak ต้อง upgrade เป็น Rc ก่อนใช้
    if let Some(value) = weak.upgrade() {
        println!("Value: {}", value);  // 5
    }

    // Drop strong reference
    drop(strong);

    // Weak upgrade ไม่ได้แล้ว
    assert!(weak.upgrade().is_none());
    println!("Data is gone!");
}

ตัวอย่าง: Tree Structure

use std::rc::{Rc, Weak};
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,      // Weak ไป parent
    children: RefCell<Vec<Rc<Node>>>, // Strong ไป children
}

fn main() {
    // สร้าง leaf node
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!("leaf strong count: {}", Rc::strong_count(&leaf));  // 1

    // สร้าง branch node
    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    // ตั้ง parent ของ leaf (weak reference)
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    println!("After linking:");
    println!("  leaf strong: {}", Rc::strong_count(&leaf));    // 2 (leaf + branch's child)
    println!("  branch strong: {}", Rc::strong_count(&branch)); // 1
    println!("  branch weak: {}", Rc::weak_count(&branch));     // 1 (leaf's parent)

    // Access parent
    if let Some(parent) = leaf.parent.borrow().upgrade() {
        println!("leaf's parent value: {}", parent.value);  // 5
    }
}

ทำไมถึงไม่ leak?

              branch (strong=1, weak=1)
                ^ Weak
                |
              +-+
              |
leaf ---------+ Strong (in children vec)

When branch goes out of scope:
1. branch's strong=0 -> branch is dropped
2. leaf's strong -1 (from branch's children)
3. leaf's strong=1 -> still alive
4. leaf's parent.upgrade() = None

เมื่อไหร่ใช้ Weak?

ตัวอย่าง: Observer Pattern

use std::rc::{Rc, Weak};
use std::cell::RefCell;

trait Observer {
    fn notify(&self, message: &str);
}

struct Subject {
    observers: RefCell<Vec<Weak<dyn Observer>>>,
}

impl Subject {
    fn new() -> Subject {
        Subject {
            observers: RefCell::new(vec![]),
        }
    }

    fn subscribe(&self, observer: &Rc<dyn Observer>) {
        self.observers.borrow_mut().push(Rc::downgrade(observer));
    }

    fn notify_all(&self, message: &str) {
        // Clean up dead observers and notify living ones
        self.observers.borrow_mut().retain(|weak| {
            if let Some(observer) = weak.upgrade() {
                observer.notify(message);
                true  // keep
            } else {
                false // remove dead reference
            }
        });
    }
}

struct Logger;
impl Observer for Logger {
    fn notify(&self, message: &str) {
        println!("[LOG] {}", message);
    }
}

fn main() {
    let subject = Subject::new();

    {
        let logger: Rc<dyn Observer> = Rc::new(Logger);
        subject.subscribe(&logger);

        subject.notify_all("Hello");  // [LOG] Hello
    }  // logger dropped here

    subject.notify_all("World");  // Nothing printed, observer is gone
}

Weak Methods

ลองทำดู! 🎯

1. สร้าง doubly-linked list ด้วย Rc + Weak
2. สร้าง observer pattern
3. ลอง drop Rc แล้วดู Weak::upgrade()

สรุปบทที่ 14

Patterns

// Tree data structure
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,      // Weak up
    children: RefCell<Vec<Rc<Node>>>, // Strong down
}

// Shared mutable state
Rc<RefCell<T>>

// Break reference cycles
Weak<T>

👉 ต่อไป: บทที่ 15: Concurrency

บทที่ 15: Concurrency - การทำงานพร้อมกัน

Rust ทำให้ concurrent programming ปลอดภัย

สิ่งที่จะได้เรียนรู้

👉 Threads

Threads

การสร้างและจัดการ threads ใน Rust

🧵 Thread Visualization

+-------------------------------------------------------------------+
|                    Multi-Threading in Rust                        |
+-------------------------------------------------------------------+
|                                                                   |
|   Main Thread                 Spawned Thread                      |
|   -----------                 --------------                      |
|       |                                                           |
|       | spawn -----------------------> |                          |
|       |                                |                          |
|       v                                v                          |
|   +-------+                       +-------+                       |
|   | Task1 |                       | TaskA |                       |
|   +-------+                       +-------+                       |
|       |                                |                          |
|   +-------+                       +-------+                       |
|   | Task2 |                       | TaskB |                       |
|   +-------+                       +-------+                       |
|       |                                |                          |
|       | <-------- join() -------------+                           |
|       |                                                           |
|       v                                                           |
|    Continue                                                       |
|                                                                   |
+-------------------------------------------------------------------+

สร้าง Thread

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("hi from spawned thread: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..3 {
        println!("hi from main thread: {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    // รอ thread จบ
    handle.join().unwrap();
}

Output (อาจต่างกันแต่ละครั้ง):

hi from main thread: 1
hi from spawned thread: 1
hi from main thread: 2
hi from spawned thread: 2
hi from spawned thread: 3
hi from spawned thread: 4

JoinHandle

thread::spawn returns JoinHandle<T>:

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // return value from thread
        42
    });

    // join() returns Result<T, E>
    let result = handle.join().unwrap();
    println!("Thread returned: {}", result);
}

รอหลาย Threads

use std::thread;

fn main() {
    let mut handles = vec![];

    for i in 0..5 {
        let handle = thread::spawn(move || {
            println!("Thread {} starting", i);
            i * 2
        });
        handles.push(handle);
    }

    // รอทุก threads จบ
    let results: Vec<i32> = handles
        .into_iter()
        .map(|h| h.join().unwrap())
        .collect();

    println!("Results: {:?}", results);
}

Move Closure

ใช้ move เพื่อย้าย ownership เข้า thread:

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    // ❌ Error: closure may outlive the current function
    // let handle = thread::spawn(|| {
    //     println!("vector: {:?}", v);
    // });

    // ✅ ใช้ move
    let handle = thread::spawn(move || {
        println!("vector: {:?}", v);
    });

    // println!("{:?}", v); // ❌ v was moved

    handle.join().unwrap();
}

Thread Builder

กำหนด thread name และ stack size:

use std::thread;

fn main() {
    let builder = thread::Builder::new()
        .name("worker".to_string())
        .stack_size(4 * 1024 * 1024); // 4MB stack

    let handle = builder.spawn(|| {
        println!("Thread name: {:?}", thread::current().name());
    }).unwrap();

    handle.join().unwrap();
}

Thread Information

use std::thread;

fn main() {
    // Current thread info
    let current = thread::current();
    println!("Main thread name: {:?}", current.name());
    println!("Main thread id: {:?}", current.id());

    let handle = thread::spawn(|| {
        let current = thread::current();
        println!("Spawned thread name: {:?}", current.name());
        println!("Spawned thread id: {:?}", current.id());
    });

    handle.join().unwrap();

    // จำนวน CPU cores
    println!("Available parallelism: {:?}", thread::available_parallelism());
}

Panic Handling in Threads

Panic ใน thread หนึ่งไม่กระทบ threads อื่น:

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        panic!("oops!");
    });

    // join() returns Err if thread panicked
    match handle.join() {
        Ok(_) => println!("Thread completed successfully"),
        Err(e) => println!("Thread panicked: {:?}", e),
    }

    println!("Main thread continues!");
}

Thread Parking

หยุด thread ชั่วคราว:

use std::thread;
use std::time::Duration;

fn main() {
    let parked_thread = thread::spawn(|| {
        println!("Thread starting, will park...");
        thread::park();  // รอจนกว่าจะถูก unpark
        println!("Thread unparked!");
    });

    thread::sleep(Duration::from_secs(1));
    println!("Main thread unparking the other thread");
    parked_thread.thread().unpark();

    parked_thread.join().unwrap();
}

Scoped Threads (Rust 1.63+)

ยืม data โดยไม่ต้อง move:

use std::thread;

fn main() {
    let numbers = vec![1, 2, 3];

    thread::scope(|s| {
        s.spawn(|| {
            println!("numbers: {:?}", numbers);  // borrow, not move!
        });

        s.spawn(|| {
            println!("length: {}", numbers.len());
        });
    });  // threads จบเมื่อ scope จบ

    // numbers ยังใช้ได้!
    println!("After scope: {:?}", numbers);
}

ตัวอย่างจริง: Parallel Computation

use std::thread;

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let chunk_size = data.len() / 2;

    let (left, right) = data.split_at(chunk_size);

    thread::scope(|s| {
        let left_sum = s.spawn(|| -> i32 {
            left.iter().sum()
        });

        let right_sum = s.spawn(|| -> i32 {
            right.iter().sum()
        });

        let total = left_sum.join().unwrap() + right_sum.join().unwrap();
        println!("Total sum: {}", total);
    });
}

ลองทำดู! 🎯

1. สร้าง 3 threads ที่ print message แล้วรอทุก thread จบ
2. ใช้ thread::scope เพื่อ borrow data
3. จัดการ panic ใน thread ด้วย join()

💪 Advanced Exercises

Exercise 1: Parallel Sum

// เขียน function ที่คำนวณ sum ของ vector โดยแบ่งงานให้ 4 threads
fn parallel_sum(numbers: Vec<i32>) -> i32 {
    // TODO: แบ่ง vector เป็น 4 ส่วน
    // TODO: สร้าง 4 threads คำนวณ sum แต่ละส่วน  
    // TODO: รวมผลลัพธ์
    todo!()
}

use std::thread;

fn parallel_sum(numbers: Vec<i32>) -> i32 {
    let chunk_size = numbers.len() / 4;
    let chunks: Vec<Vec<i32>> = numbers
        .chunks(chunk_size)
        .map(|c| c.to_vec())
        .collect();
    
    let handles: Vec<_> = chunks
        .into_iter()
        .map(|chunk| {
            thread::spawn(move || chunk.iter().sum::<i32>())
        })
        .collect();
    
    handles.into_iter().map(|h| h.join().unwrap()).sum()
}

Exercise 2: Thread-Safe Counter

// สร้าง counter ที่หลาย threads เพิ่มค่าพร้อมกันได้
// Hint: ใช้ Arc<Mutex<i32>>

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        }));
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Result: {}", *counter.lock().unwrap()); // 10
}

📝 ทดสอบความเข้าใจ

สรุป

👉 ต่อไป: Message Passing

Message Passing

ส่งข้อมูลระหว่าง threads ด้วย channels

Basic Channel

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

Multiple Messages

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let vals = vec!["hi", "from", "thread"];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });

    for received in rx {
        println!("Got: {}", received);
    }
}

Multiple Producers

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();

    thread::spawn(move || {
        tx.send("from thread 1").unwrap();
    });

    thread::spawn(move || {
        tx1.send("from thread 2").unwrap();
    });

    for received in rx {
        println!("Got: {}", received);
    }
}

👉 ต่อไป: Shared State

Shared State

แชร์ข้อมูลระหว่าง threads ด้วย Mutex

Mutex

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5);

    {
        let mut num = m.lock().unwrap();
        *num = 6;
    } // lock released here

    println!("m = {:?}", m);
}

⚠️ คำเตือน: อันตรายของ Concurrency

• 🔴 Deadlock - 2 threads รอกันไปมา ไม่มีใครทำงานต่อ
• 🔴 Data Race - หลาย threads แก้ไขข้อมูลพร้อมกัน
• 🔴 Poison - Mutex ถูก poison ถ้า thread panic ขณะถือ lock

+---------------------------------------------------------+
|                    Deadlock Example                     |
+---------------------------------------------------------+
|  Thread A: lock(mutex1) -> wait lock(mutex2)             |
|  Thread B: lock(mutex2) -> wait lock(mutex1)             |
|  !! ทั้งสองรอกันตลอดไป!                                  |
+---------------------------------------------------------+

💡 Best Practices

• ✅ Lock เร็วที่สุด, ปล่อยเร็วที่สุด
• ✅ Lock ตามลำดับเดียวกันทุก thread
• ✅ ใช้ try_lock() เพื่อหลีกเลี่ยง deadlock
• ✅ ใช้ channels แทน shared state เมื่อเป็นไปได้

Arc + Mutex

Arc = Atomic Reference Counting (thread-safe Rc)

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap()); // 10
}

👉 ต่อไป: Sync & Send

Sync & Send

Marker traits สำหรับ concurrency

Send

Type ที่ส่งระหว่าง threads ได้:

#![allow(unused)]
fn main() {
// Most types are Send
// Rc<T> is NOT Send (use Arc<T> instead)
}

Sync

Type ที่หลาย threads เข้าถึงพร้อมกันได้:

#![allow(unused)]
fn main() {
// T is Sync if &T is Send
// RefCell<T> is NOT Sync
// Mutex<T> IS Sync
}

สรุปบทที่ 15

👉 ต่อไป: บทที่ 16: Async/Await

บทที่ 16: Async/Await

Asynchronous programming สำหรับ I/O-bound tasks

สิ่งที่จะได้เรียนรู้

👉 Async พื้นฐาน

Async พื้นฐาน

Asynchronous programming ใน Rust ช่วยจัดการ I/O-bound tasks อย่างมีประสิทธิภาพ

⚡ Async vs Sync Visualization

Sync vs Async

Synchronous (Blocking)

fn main() {
    let data1 = fetch_data_1(); // รอ... 2 seconds
    let data2 = fetch_data_2(); // รอ... 2 seconds
    // Total: 4 seconds
}

Asynchronous (Non-blocking)

async fn main() {
    let (data1, data2) = join!(
        fetch_data_1(), // เริ่มพร้อมกัน
        fetch_data_2()
    );
    // Total: ~2 seconds
}

async fn

async fn hello_world() {
    println!("Hello, world!");
}

// async fn returns a Future
// must be run by an executor

async fn returns impl Future - ไม่รันทันที ต้อง await หรือใช้ executor

.await

async fn fetch_number() -> i32 {
    // simulate async work
    42
}

async fn main() {
    let number = fetch_number().await; // รอ Future complete
    println!("Number: {}", number);
}

Sequential vs Concurrent

async fn learn_song() -> String {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    "La la la".to_string()
}

async fn sing_song(song: &str) {
    println!("Singing: {}", song);
}

async fn dance() {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    println!("Dancing!");
}

// Sequential
async fn sequential() {
    let song = learn_song().await; // 1 sec
    sing_song(&song).await;
    dance().await;                  // 1 sec
    // Total: 2+ seconds
}

// Concurrent - dance while learning
async fn concurrent() {
    let (song, _) = tokio::join!(
        learn_song(),  // start learning
        dance()        // dance at the same time
    );
    sing_song(&song).await;
    // Total: ~1 second (overlapped)
}

Runtime: Tokio

Rust ไม่มี async runtime ในตัว ต้องใช้ library:

# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }

Basic Usage

#[tokio::main]
async fn main() {
    println!("Hello from async main!");

    let result = do_something().await;
    println!("Result: {}", result);
}

async fn do_something() -> i32 {
    // simulate async work
    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
    42
}

Manual Runtime

fn main() {
    let rt = tokio::runtime::Runtime::new().unwrap();

    rt.block_on(async {
        println!("Running on tokio runtime");
    });
}

async Block

async fn example() {
    let future = async {
        // code here runs lazily
        println!("Inside async block");
        42
    };

    // future ยังไม่รัน!
    let result = future.await;
    println!("Result: {}", result);
}

Capture Variables

async fn example() {
    let name = String::from("Alice");

    // move ownership into async block
    let greeting = async move {
        format!("Hello, {}!", name)
    };

    // name moved, can't use here
    // println!("{}", name); // ❌

    println!("{}", greeting.await);
}

Futures are Lazy

async fn my_async_fn() {
    println!("This runs when awaited");
}

fn main() {
    let future = my_async_fn(); // ไม่รันอะไรเลย!

    // ต้อง await หรือใช้ executor
    // future.await; // or
    // tokio::runtime::Runtime::new().unwrap().block_on(future);
}

Return Types

use std::future::Future;

// These are equivalent:
async fn foo() -> i32 {
    42
}

fn bar() -> impl Future<Output = i32> {
    async {
        42
    }
}

Error Handling in Async

async fn fetch_data() -> Result<String, std::io::Error> {
    // simulate possible failure
    Ok("data".to_string())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let data = fetch_data().await?;
    println!("Data: {}", data);
    Ok(())
}

Async in Traits (Rust 1.75+)

trait AsyncFetcher {
    async fn fetch(&self) -> String;
}

struct MyFetcher;

impl AsyncFetcher for MyFetcher {
    async fn fetch(&self) -> String {
        "data".to_string()
    }
}

When to Use Async

ลองทำดู! 🎯

1. สร้าง async function ที่ return Result
2. ใช้ tokio::time::sleep แล้ว await
3. ลอง tokio::join! กับ 2 futures

สรุป

Runtimes

👉 ต่อไป: Futures

Futures

Future คือ trait หลักของ async programming ใน Rust

Future Trait

pub trait Future {
    type Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

pub enum Poll<T> {
    Ready(T),   // Future เสร็จแล้ว มีค่า T
    Pending,    // ยังไม่เสร็จ ให้ poll อีกทีหลัง
}

ทำงานอย่างไร?

                    +-------------+
                    |   Future    |
                    +------+------+ 
                           | poll()
                           v
              +-------------+-------------+
              |                           |
        Poll::Ready(T)            Poll::Pending
        (เสร็จแล้ว)              (รอก่อน)
              |                           |
              v                           v
         ใช้ค่า T              Executor จะ poll อีกครั้งเมื่อพร้อม

async Block

สร้าง anonymous Future:

async fn example() {
    let future = async {
        println!("Inside async block");
        42
    };

    // future ยังไม่รัน!
    let result = future.await;  // รันตอนนี้
    println!("Result: {}", result);
}

Futures are Lazy

สำคัญมาก: Future ไม่ทำอะไรจนกว่าจะถูก poll

async fn do_something() {
    println!("This runs when polled!");
}

fn main() {
    let future = do_something(); // ไม่ print!

    // ต้อง await หรือใช้ executor
    // ไม่งั้น future จะไม่ทำอะไรเลย

    drop(future); // ทิ้งทั้งที่ยังไม่ได้รัน
}

Combine Futures

Sequential

async fn sequential() {
    let a = async_fn_1().await;  // รัน 1 ก่อน
    let b = async_fn_2().await;  // แล้วรัน 2
    println!("{} {}", a, b);
}

Concurrent กับ join!

use tokio::join;

async fn concurrent() {
    // รันพร้อมกัน!
    let (a, b) = join!(
        async_fn_1(),
        async_fn_2()
    );
    println!("{} {}", a, b);
}

Racing กับ select!

use tokio::select;

async fn race() {
    select! {
        result = async_fn_1() => println!("1 finished: {}", result),
        result = async_fn_2() => println!("2 finished: {}", result),
    }
    // แค่อันแรกที่เสร็จ
}

Pin คืออะไร?

Pin ป้องกัน Future ไม่ให้ถูก move ในหน่วยความจำ:

use std::pin::Pin;
use std::future::Future;

fn takes_future(future: Pin<&mut dyn Future<Output = i32>>) {
    // future ถูก pin ไว้จะ move ไม่ได้
}

ทำไมต้อง Pin?

• บาง Future มี self-references
• ถ้า move แล้ว references จะ invalid
• Pin รับประกันว่าจะไม่ move

สร้าง Future เอง (Advanced)

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct MyFuture {
    count: u32,
}

impl Future for MyFuture {
    type Output = u32;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        self.count += 1;
        if self.count >= 3 {
            Poll::Ready(self.count)
        } else {
            cx.waker().wake_by_ref(); // บอกให้ poll อีกครั้ง
            Poll::Pending
        }
    }
}

async fn vs Future

// ทั้งสองเหมือนกัน:

async fn foo() -> i32 {
    42
}

fn bar() -> impl Future<Output = i32> {
    async { 42 }
}

ลองทำดู! 🎯

1. สร้าง async function ที่ return String
2. ใช้ join! รวม 2 futures
3. ลองสร้าง future แล้วไม่ await ดูว่าเกิดอะไร

สรุป

👉 ต่อไป: Tokio Runtime

Tokio Runtime

Tokio เป็น async runtime ที่นิยมที่สุดใน Rust ecosystem

Setup

# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }
```text

Features ที่มี:

| Feature           | Description                    |
| ----------------- | ------------------------------ |
| `rt`              | Runtime core                   |
| `rt-multi-thread` | Multi-threaded runtime         |
| `time`            | tokio::time                    |
| `net`             | TCP/UDP networking             |
| `io-util`         | I/O utilities                  |
| `sync`            | Synchronization primitives     |
| `macros`          | #[tokio::main], #[tokio::test] |
| `full`            | ทุกอย่าง                       |

---

## Basic Usage

```rust,ignore
#[tokio::main]
async fn main() {
    println!("Hello from Tokio!");

    let result = do_something().await;
    println!("Result: {}", result);
}

async fn do_something() -> String {
    // simulate async work
    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
    "Done!".to_string()
}

#[tokio::main] ทำอะไร?

// มันแปลง:
#[tokio::main]
async fn main() {
    // code
}

// เป็น:
fn main() {
    tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap()
        .block_on(async {
            // code
        })
}

Manual Runtime

fn main() {
    // สร้าง runtime เอง
    let rt = tokio::runtime::Runtime::new().unwrap();

    // รัน future
    rt.block_on(async {
        println!("Running on Tokio!");
    });

    // หรือ spawn และ block
    let handle = rt.spawn(async {
        42
    });

    let result = rt.block_on(handle).unwrap();
    println!("Result: {}", result);
}

Runtime Types

// Multi-threaded (default)
let rt = tokio::runtime::Builder::new_multi_thread()
    .worker_threads(4)
    .enable_all()
    .build()
    .unwrap();

// Single-threaded (current thread)
let rt = tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .build()
    .unwrap();

Spawning Tasks

tokio::spawn

use tokio::task;

#[tokio::main]
async fn main() {
    // Spawn task - รันแบบ concurrent
    let handle = task::spawn(async {
        println!("Hello from spawned task!");
        42
    });

    // รอผลลัพธ์
    let result = handle.await.unwrap();
    println!("Task returned: {}", result);
}

Multiple Tasks

use tokio::task;

#[tokio::main]
async fn main() {
    let mut handles = vec![];

    for i in 0..5 {
        let handle = task::spawn(async move {
            println!("Task {} running", i);
            i * 2
        });
        handles.push(handle);
    }

    // รอทุก tasks
    for handle in handles {
        let result = handle.await.unwrap();
        println!("Result: {}", result);
    }
}

Concurrent Execution

join! - รอทุก futures

use tokio::join;
use tokio::time::{sleep, Duration};

async fn task_a() -> i32 {
    sleep(Duration::from_millis(100)).await;
    1
}

async fn task_b() -> i32 {
    sleep(Duration::from_millis(200)).await;
    2
}

#[tokio::main]
async fn main() {
    // รันพร้อมกัน, รอทุกอันเสร็จ
    let (a, b) = join!(task_a(), task_b());

    println!("Results: {} + {} = {}", a, b, a + b);
    // ใช้เวลา ~200ms (ไม่ใช่ 300ms)
}

try_join! - หยุดเมื่อ error

use tokio::try_join;

async fn may_fail(succeed: bool) -> Result<i32, &'static str> {
    if succeed {
        Ok(42)
    } else {
        Err("failed!")
    }
}

#[tokio::main]
async fn main() {
    let result = try_join!(
        may_fail(true),
        may_fail(true)
    );

    match result {
        Ok((a, b)) => println!("Both succeeded: {}, {}", a, b),
        Err(e) => println!("One failed: {}", e),
    }
}

Tokio Time

use tokio::time::{sleep, interval, Duration, Instant};

#[tokio::main]
async fn main() {
    // Sleep
    println!("Sleeping...");
    sleep(Duration::from_secs(1)).await;
    println!("Woke up!");

    // Interval
    let mut interval = interval(Duration::from_millis(500));
    for _ in 0..3 {
        interval.tick().await;
        println!("Tick!");
    }

    // Measure time
    let start = Instant::now();
    sleep(Duration::from_millis(100)).await;
    println!("Elapsed: {:?}", start.elapsed());
}

Tokio Channels

mpsc - Multiple Producer Single Consumer

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);  // buffer size 32

    // Spawn sender
    let tx1 = tx.clone();
    tokio::spawn(async move {
        tx1.send("Hello from task 1").await.unwrap();
    });

    tokio::spawn(async move {
        tx.send("Hello from task 2").await.unwrap();
    });

    // Receive
    while let Some(msg) = rx.recv().await {
        println!("Received: {}", msg);
    }
}

oneshot - Single value

use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();

    tokio::spawn(async move {
        tx.send("Result!").unwrap();
    });

    let result = rx.await.unwrap();
    println!("Got: {}", result);
}

ลองทำดู! 🎯

1. สร้าง 3 tasks ด้วย tokio::spawn และรอทุก task
2. ใช้ interval พิมพ์ทุก 1 วินาที
3. ใช้ mpsc channel ส่งข้อมูลระหว่าง tasks

สรุป

👉 ต่อไป: Async Patterns

Async Patterns

รูปแบบการเขียน async code ที่พบบ่อย

select! - Racing Futures

รอหลาย futures พร้อมกัน ใช้อันแรกที่เสร็จ:

use tokio::select;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    select! {
        _ = sleep(Duration::from_secs(1)) => {
            println!("1 second elapsed");
        }
        _ = sleep(Duration::from_secs(2)) => {
            println!("2 seconds elapsed");
        }
    }
    // จะ print "1 second elapsed" เพราะเสร็จก่อน
}

select! กับ Return Values

use tokio::select;
use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx1, mut rx1) = mpsc::channel::<i32>(1);
    let (tx2, mut rx2) = mpsc::channel::<String>(1);

    // Spawn senders
    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
        tx1.send(42).await.unwrap();
    });

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
        tx2.send("hello".to_string()).await.unwrap();
    });

    select! {
        Some(val) = rx1.recv() => println!("Got number: {}", val),
        Some(val) = rx2.recv() => println!("Got string: {}", val),
    }
    // จะได้ string เพราะ 50ms < 100ms
}

Timeout

ให้ future มีเวลาจำกัด:

use tokio::time::{timeout, Duration};

async fn slow_function() -> String {
    tokio::time::sleep(Duration::from_secs(10)).await;
    "Done!".to_string()
}

#[tokio::main]
async fn main() {
    let result = timeout(
        Duration::from_secs(2),  // timeout หลัง 2 วินาที
        slow_function()
    ).await;

    match result {
        Ok(value) => println!("Got: {}", value),
        Err(_) => println!("Timeout! Function took too long."),
    }
}

Timeout กับ select!

use tokio::select;
use tokio::time::{sleep, Duration};

async fn fetch_data() -> String {
    sleep(Duration::from_secs(5)).await;
    "Data".to_string()
}

#[tokio::main]
async fn main() {
    select! {
        result = fetch_data() => {
            println!("Got: {}", result);
        }
        _ = sleep(Duration::from_secs(2)) => {
            println!("Timeout!");
        }
    }
}

Retry Pattern

ลองใหม่เมื่อ fail:

use std::sync::atomic::{AtomicU32, Ordering};

async fn fallible_operation() -> Result<String, &'static str> {
    // Simulate random failure
    static ATTEMPT: AtomicU32 = AtomicU32::new(0);
    
    // fetch_add returns the previous value
    let count = ATTEMPT.fetch_add(1, Ordering::SeqCst);
    
    if count < 3 {
        Err("failed")
    } else {
        Ok("success!".to_string())
    }
}

async fn retry<F, Fut, T, E>(f: F, max_retries: u32) -> Result<T, E>
where
    F: Fn() -> Fut,
    Fut: std::future::Future<Output = Result<T, E>>,
{
    let mut attempt = 0;
    loop {
        match f().await {
            Ok(value) => return Ok(value),
            Err(e) => {
                attempt += 1;
                if attempt >= max_retries {
                    return Err(e);
                }
                println!("Retry attempt {}/{}", attempt, max_retries);
                sleep(Duration::from_millis(100 * attempt as u64)).await;
            }
        }
    }
}

#[tokio::main]
async fn main() {
    let result = retry(|| fallible_operation(), 5).await;
    println!("Result: {:?}", result);
}

Graceful Shutdown

ปิดโปรแกรมอย่างสะอาด:

use tokio::signal;
use tokio::sync::broadcast;

#[tokio::main]
async fn main() {
    // สร้าง shutdown signal
    let (shutdown_tx, _) = broadcast::channel::<()>(1);

    // Spawn workers
    for i in 0..3 {
        let mut rx = shutdown_tx.subscribe();
        tokio::spawn(async move {
            loop {
                tokio::select! {
                    _ = rx.recv() => {
                        println!("Worker {} shutting down", i);
                        break;
                    }
                    _ = tokio::time::sleep(std::time::Duration::from_secs(1)) => {
                        println!("Worker {} working...", i);
                    }
                }
            }
        });
    }

    // รอ Ctrl+C
    signal::ctrl_c().await.unwrap();
    println!("Shutdown signal received!");

    // ส่ง shutdown
    drop(shutdown_tx);

    // รอให้ workers เสร็จ
    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
    println!("Goodbye!");
}

Rate Limiting

จำกัดความถี่:

use tokio::time::{interval, Duration};
use tokio::sync::Semaphore;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    // อนุญาตแค่ 3 concurrent requests
    let semaphore = Arc::new(Semaphore::new(3));

    let mut handles = vec![];

    for i in 0..10 {
        let permit = semaphore.clone().acquire_owned().await.unwrap();

        let handle = tokio::spawn(async move {
            println!("Request {} started", i);
            tokio::time::sleep(Duration::from_millis(500)).await;
            println!("Request {} done", i);
            drop(permit);  // release permit
        });

        handles.push(handle);
    }

    for handle in handles {
        handle.await.unwrap();
    }
}

Buffering and Batching

รวม items ก่อน process:

use tokio::sync::mpsc;
use tokio::time::{timeout, Duration};

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel::<i32>(100);

    // Producer
    tokio::spawn(async move {
        for i in 0..20 {
            tx.send(i).await.unwrap();
            tokio::time::sleep(Duration::from_millis(50)).await;
        }
    });

    // Consumer with batching
    let batch_size = 5;
    let batch_timeout = Duration::from_millis(200);

    loop {
        let mut batch = Vec::with_capacity(batch_size);

        // Collect batch
        loop {
            let result = timeout(batch_timeout, rx.recv()).await;

            match result {
                Ok(Some(item)) => {
                    batch.push(item);
                    if batch.len() >= batch_size {
                        break;
                    }
                }
                Ok(None) => break,  // channel closed
                Err(_) => break,     // timeout
            }
        }

        if batch.is_empty() {
            break;
        }

        println!("Processing batch: {:?}", batch);
    }
}

ลองทำดู! 🎯

1. ใช้ select! เลือกระหว่าง 2 async operations
2. สร้าง function ที่มี timeout
3. implement retry logic สำหรับ API call

สรุปบทที่ 16

เปรียบเทียบ

👉 ต่อไป: บทที่ 17: Unsafe Rust

บทที่ 17: Unsafe Rust

unsafe ช่วยให้ทำสิ่งที่ compiler ตรวจสอบไม่ได้

สิ่งที่จะได้เรียนรู้

👉 Unsafe คืออะไร

Unsafe คืออะไร

unsafe ปลดล็อคความสามารถพิเศษที่ compiler ตรวจสอบไม่ได้

🚨 อันตราย!

unsafe หมายความว่าคุณ รับผิดชอบ ความถูกต้องแทน compiler:

• ❌ Memory corruption
• ❌ Data races
• ❌ Undefined behavior
• ❌ Security vulnerabilities

ใช้ unsafe เมื่อจำเป็นจริงๆ เท่านั้น!

Unsafe Superpowers

ใน unsafe block ทำได้ 5 อย่าง: