Merge pull request #77 from rust-tieng-viet/claude/update-content-pages-011CULRESPubffdRFHtEnwrR

feat: update outdated content and add comprehensive content to empty pages

Author: duyet

src/SUMMARY.md

@@ -120,7 +120,6 @@
 
 - [Viết Docs](./basic/rustdoc/README.md)
 
-  - [Doc comments](./basic/code-comment/doc-comment.md)
   - [Sử dụng README.md làm crate document](./basic/rustdoc/doc-README.md)
 
 
@@ -175,12 +174,6 @@
 # Data Engineering
 
 - [Xử lý và phân tích dữ liệu](./data-engineering/data-processing.md)
-  - [Polars](./crates/polars.md)
-  - [serde](./crates/serde.md)
-    - [serde_json](./crates/serde/serde_json.md)
-    - [serde_toml](./crates/serde/serde_toml.md)
-    - [serde_csv](./crates/serde/serde_csv.md)
-    - [serde_yaml](./crates/serde/serde_yaml.md)
 - [High-performance data pipeline](./data-engineering/first-data-pipeline.md)
 - [Building scalable data-driven applications using Rust](./data-engineering/data-driven.md)
 - [Rust as an alternative to Python for data engineering tasks](./data-engineering/rust-as-alternative-python.md)

src/basic/match/literals.md

@@ -1 +1,161 @@
 # Matching giá trị
+
+Pattern matching với literals (giá trị cụ thể) là cách sử dụng phổ biến nhất của `match` trong Rust. Bạn có thể match trực tiếp với các giá trị cụ thể như số, ký tự, hay chuỗi.
+
+## Match với số nguyên
+
+```rust
+fn describe_number(x: i32) {
+    match x {
+        1 => println!("Một"),
+        2 => println!("Hai"),
+        3 => println!("Ba"),
+        _ => println!("Số khác"),
+    }
+}
+
+fn main() {
+    describe_number(1);  // In ra: Một
+    describe_number(5);  // In ra: Số khác
+}
+```
+
+Pattern `_` (underscore) là một wildcard pattern, match với mọi giá trị còn lại. Nó giống như `default` case trong `switch` của C/Java.
+
+## Match với ký tự
+
+```rust
+fn describe_char(c: char) {
+    match c {
+        'a' => println!("Chữ a"),
+        'b' => println!("Chữ b"),
+        '0'..='9' => println!("Một chữ số"),
+        _ => println!("Ký tự khác"),
+    }
+}
+
+fn main() {
+    describe_char('a');  // In ra: Chữ a
+    describe_char('5');  // In ra: Một chữ số
+    describe_char('z');  // In ra: Ký tự khác
+}
+```
+
+Ở ví dụ trên, `'0'..='9'` là range pattern, match với mọi ký tự từ '0' đến '9'.
+
+## Match với boolean
+
+```rust
+fn is_true(b: bool) -> &'static str {
+    match b {
+        true => "Đúng rồi!",
+        false => "Sai rồi!",
+    }
+}
+
+fn main() {
+    println!("{}", is_true(true));   // In ra: Đúng rồi!
+    println!("{}", is_true(false));  // In ra: Sai rồi!
+}
+```
+
+Với boolean, bạn không cần dùng `_` vì chỉ có 2 giá trị: `true` và `false`.
+
+## Match với range
+
+```rust
+fn categorize_age(age: u32) {
+    match age {
+        0 => println!("Trẻ sơ sinh"),
+        1..=12 => println!("Trẻ em"),
+        13..=19 => println!("Thiếu niên"),
+        20..=64 => println!("Người trưởng thành"),
+        65..=u32::MAX => println!("Người cao tuổi"),
+    }
+}
+
+fn main() {
+    categorize_age(5);   // In ra: Trẻ em
+    categorize_age(25);  // In ra: Người trưởng thành
+    categorize_age(70);  // In ra: Người cao tuổi
+}
+```
+
+Cú pháp `1..=12` là inclusive range (bao gồm cả 1 và 12). Nếu dùng `1..12` thì sẽ là exclusive range (từ 1 đến 11, không bao gồm 12).
+
+## Exhaustiveness Checking
+
+Một điểm mạnh của `match` trong Rust là compiler sẽ kiểm tra xem bạn đã xử lý hết tất cả các trường hợp chưa. Điều này giúp tránh bugs.
+
+```rust
+fn check_number(x: i32) {
+    match x {
+        1 => println!("Một"),
+        2 => println!("Hai"),
+        // ❌ Compiler sẽ báo lỗi: pattern `i32::MIN..=0_i32` and `3_i32..=i32::MAX` not covered
+    }
+}
+```
+
+Bạn phải xử lý tất cả các trường hợp, hoặc sử dụng `_` để bắt các trường hợp còn lại:
+
+```rust
+fn check_number(x: i32) {
+    match x {
+        1 => println!("Một"),
+        2 => println!("Hai"),
+        _ => println!("Số khác"),  // ✅ OK
+    }
+}
+```
+
+## So sánh với `if-else`
+
+Trong một số ngôn ngữ khác như JavaScript hay Python, bạn có thể dùng `if-else` để làm việc tương tự:
+
+```javascript
+// JavaScript
+function describeNumber(x) {
+  if (x === 1) {
+    console.log("Một");
+  } else if (x === 2) {
+    console.log("Hai");
+  } else if (x === 3) {
+    console.log("Ba");
+  } else {
+    console.log("Số khác");
+  }
+}
+```
+
+Tuy nhiên `match` trong Rust có nhiều ưu điểm hơn:
+- Compiler kiểm tra exhaustiveness (đã xử lý hết tất cả trường hợp chưa)
+- Dễ đọc và rõ ràng hơn với nhiều trường hợp
+- Có thể match với pattern phức tạp (struct, enum, ...)
+
+## Trả về giá trị
+
+`match` là một expression, có nghĩa là nó có thể trả về giá trị:
+
+```rust
+fn number_to_string(x: i32) -> String {
+    match x {
+        1 => "một".to_string(),
+        2 => "hai".to_string(),
+        3 => "ba".to_string(),
+        _ => format!("số {}", x),
+    }
+}
+
+fn main() {
+    let result = number_to_string(2);
+    println!("{}", result);  // In ra: hai
+}
+```
+
+Tất cả các arm (nhánh) của `match` phải trả về cùng một kiểu dữ liệu.
+
+## References
+
+- [Match - The Rust Programming Language](https://doc.rust-lang.org/book/ch06-02-match.html)
+- [Patterns and Matching](https://doc.rust-lang.org/book/ch18-00-patterns.html)

src/basic/match/multiple.md

@@ -1 +1,212 @@
 # Matching Multiple
+
+Trong Rust, bạn có thể match nhiều pattern trong cùng một arm của `match` expression. Điều này giúp code ngắn gọn và dễ đọc hơn khi nhiều giá trị cần được xử lý giống nhau.
+
+## Match nhiều giá trị với `|` (OR pattern)
+
+Toán tử `|` (pipe) cho phép bạn match nhiều pattern trong cùng một arm:
+
+```rust
+fn describe_number(x: i32) {
+    match x {
+        1 | 2 => println!("Một hoặc hai"),
+        3 | 4 | 5 => println!("Ba, bốn hoặc năm"),
+        _ => println!("Số khác"),
+    }
+}
+
+fn main() {
+    describe_number(1);  // In ra: Một hoặc hai
+    describe_number(4);  // In ra: Ba, bốn hoặc năm
+    describe_number(7);  // In ra: Số khác
+}
+```
+
+## Kết hợp OR pattern với range
+
+Bạn có thể kết hợp nhiều pattern và range trong cùng một arm:
+
+```rust
+fn categorize_number(x: i32) {
+    match x {
+        0 => println!("Số không"),
+        1..=10 | 100 => println!("Từ 1 đến 10, hoặc 100"),
+        -1 | -2 | -3 => println!("Số âm nhỏ"),
+        _ => println!("Số khác"),
+    }
+}
+
+fn main() {
+    categorize_number(5);    // In ra: Từ 1 đến 10, hoặc 100
+    categorize_number(100);  // In ra: Từ 1 đến 10, hoặc 100
+    categorize_number(-2);   // In ra: Số âm nhỏ
+}
+```
+
+## Match với ký tự
+
+```rust
+fn is_vowel(c: char) -> bool {
+    match c {
+        'a' | 'e' | 'i' | 'o' | 'u' => true,
+        'A' | 'E' | 'I' | 'O' | 'U' => true,
+        _ => false,
+    }
+}
+
+fn main() {
+    println!("{}", is_vowel('a'));  // true
+    println!("{}", is_vowel('b'));  // false
+    println!("{}", is_vowel('E'));  // true
+}
+```
+
+Hoặc ngắn gọn hơn:
+
+```rust
+fn is_vowel(c: char) -> bool {
+    match c {
+        'a' | 'e' | 'i' | 'o' | 'u' | 'A' | 'E' | 'I' | 'O' | 'U' => true,
+        _ => false,
+    }
+}
+```
+
+## Match với enum
+
+OR pattern rất hữu ích khi làm việc với enum:
+
+```rust
+enum Direction {
+    North,
+    South,
+    East,
+    West,
+}
+
+fn is_horizontal(dir: Direction) -> bool {
+    match dir {
+        Direction::East | Direction::West => true,
+        Direction::North | Direction::South => false,
+    }
+}
+
+fn main() {
+    println!("{}", is_horizontal(Direction::East));   // true
+    println!("{}", is_horizontal(Direction::North));  // false
+}
+```
+
+## Ví dụ thực tế: HTTP status codes
+
+```rust
+fn handle_status_code(code: u16) {
+    match code {
+        200 | 201 | 202 | 204 => println!("Success"),
+        301 | 302 | 303 | 307 | 308 => println!("Redirect"),
+        400 | 401 | 403 | 404 => println!("Client error"),
+        500 | 501 | 502 | 503 => println!("Server error"),
+        _ => println!("Unknown status"),
+    }
+}
+
+fn main() {
+    handle_status_code(200);  // In ra: Success
+    handle_status_code(404);  // In ra: Client error
+    handle_status_code(500);  // In ra: Server error
+}
+```
+
+Hoặc kết hợp với range để ngắn gọn hơn:
+
+```rust
+fn handle_status_code(code: u16) {
+    match code {
+        200..=299 => println!("Success"),
+        300..=399 => println!("Redirect"),
+        400..=499 => println!("Client error"),
+        500..=599 => println!("Server error"),
+        _ => println!("Unknown status"),
+    }
+}
+```
+
+## So sánh với ngôn ngữ khác
+
+Trong JavaScript, bạn có thể sử dụng multiple `case` statements mà không có `break`:
+
+```javascript
+// JavaScript
+function describeNumber(x) {
+  switch (x) {
+    case 1:
+    case 2:
+      console.log("Một hoặc hai");
+      break;
+    case 3:
+    case 4:
+    case 5:
+      console.log("Ba, bốn hoặc năm");
+      break;
+    default:
+      console.log("Số khác");
+  }
+}
+```
+
+Trong Python (từ version 3.10), bạn có thể dùng `|` trong `match`:
+
+```python
+# Python 3.10+
+def describe_number(x):
+    match x:
+        case 1 | 2:
+            print("Một hoặc hai")
+        case 3 | 4 | 5:
+            print("Ba, bốn hoặc năm")
+        case _:
+            print("Số khác")
+```
+
+Rust's OR pattern (`|`) tương tự như Python, nhưng được kiểm tra tại compile time để đảm bảo type safety.
+
+## Match với tuple
+
+Bạn cũng có thể sử dụng OR pattern với tuple:
+
+```rust
+fn describe_point(point: (i32, i32)) {
+    match point {
+        (0, 0) => println!("Gốc tọa độ"),
+        (0, _) | (_, 0) => println!("Nằm trên trục"),
+        (x, y) if x == y => println!("Nằm trên đường chéo"),
+        _ => println!("Điểm thông thường"),
+    }
+}
+
+fn main() {
+    describe_point((0, 0));  // In ra: Gốc tọa độ
+    describe_point((0, 5));  // In ra: Nằm trên trục
+    describe_point((3, 0));  // In ra: Nằm trên trục
+    describe_point((4, 4));  // In ra: Nằm trên đường chéo
+    describe_point((2, 3));  // In ra: Điểm thông thường
+}
+```
+
+## Lưu ý quan trọng
+
+Khi sử dụng OR pattern, tất cả các pattern phải bind (gán) cùng một tập hợp các biến. Ví dụ sau sẽ **không** compile:
+
+```rust
+// ❌ Lỗi: variable `x` is not bound in all patterns
+match (1, 2) {
+    (x, _) | (_, x) => println!("{}", x),  // lỗi!
+}
+```
+
+Lý do là trong pattern đầu tiên `(x, _)`, `x` được bind với phần tử đầu tiên, nhưng trong pattern thứ hai `(_, x)`, `x` được bind với phần tử thứ hai. Compiler không thể xác định `x` nên lấy giá trị nào.
+
+## References
+
+- [Multiple Patterns - The Rust Programming Language](https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html#multiple-patterns)
+- [Patterns and Matching](https://doc.rust-lang.org/book/ch18-00-patterns.html)