## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 生命週期 lifetimes
Lifetime 是 Rust 另一大困難的 topic，Rust 透過 borrow checker 來避免出現迷途參考以確保安全性，通常情況下 lifetime 都是隱式地被 infer 出來的，但還是有情況會是需要顯式地告知 borrow checker 參考的生命週期，能夠更彈性地設計程式。

## 指定生命週期
以下函式執行時會報錯，因為這邊 Rust 無法 infer 出生命週期，認為有可能出現迷途參考，error message 也很清楚的說明需要指定生命週期。
```rust
fn main() {
 let s1 = String::from("Hello");
 let s2 = String::from("World");
 let s = get_back_str(s1.as_str(), s2.as_str()); 
 // ERROR: missing lifetime specifier
 println!("{s}");
}

fn get_back_str(s1: &str, s2: &str) -> &str {
 s1
}
```
指定生命週期使用 `'` (tick)，一般的命名慣例是以 `'a` 作為第一個生命週期的名稱。
```rust
fn main() {
 let s1 = String::from("Hello");
 let s2 = String::from("World");
 let s = get_back_str(s1.as_str(), s2.as_str());
 println!("{s}"); // Hello
}

fn get_back_str<'a>(s1: &'a str, s2: &'a str) -> &'a str {
 s1
}
```
也可以給予複數不同的生命週期，並指定回傳值的生命週期。
```rust
fn main() {
 let s1 = String::from("Hello");
 let s;
 {
 let s2 = String::from("World");
 s = get_back_str(s1.as_str(), s2.as_str());
 }
 println!("{s}"); // Hello
}

fn get_back_str<'a, 'b>(s1: &'a str, s2: &'b str) -> &'a str {
 s1
}
```
若將上面回傳值的生命週期改為 `'b` 便會報錯，錯誤訊息也很清楚告訴我們 `s2` 存活的並不夠長。
```rust
fn main() {
 let s1 = String::from("Hello");
 let s;
 {
 let s2 = String::from("World");
 s = get_back_str(s1.as_str(), s2.as_str());
 }
 println!("{s}"); // ERROR: `s2` does not live long enough
}

fn get_back_str<'a, 'b>(s1: &'a str, s2: &'b str) -> &'b str {
 s1
}
```
而如果上面程式不指定兩個生命週期僅用一個，Rust 會使用 `s1`、`s2` 兩者中生命週期較短的一個做為 `'a`，因此會得到一樣的錯誤。
```rust
fn main() {
 let s1 = String::from("Hello");
 let s;
 {
 let s2 = String::from("World");
 s = get_back_str(s1.as_str(), s2.as_str());
 }
 println!("{s}"); // ERROR: `s2` does not live long enough
}

fn get_back_str<'a>(s1: &'a str, s2: &'a str) -> &'a str {
 s1
}
```
## 在 struct 中指定生命週期
我們也可以透過指定生命週期讓參考作為 `struct` 的資料。
```rust
#[derive(Debug)]
struct User<'a> {
 name: &'a str
}

fn main() {
 let u1_name = String::from("Henry");
 let u1 = User {
 name: u1_name.as_str()
 };
 let u2;
 {
 let u2_name = String::from("Josh");
 u2 = User {
 name: u2_name.as_str()
 };
 println!("{:?}", u2); // User { name: "Josh" }
 }
 println!("{:?}", u1); // User { name: "Henry" }
}
```
如預期地，在 `u2_name` 被釋放之後取用 `u2` 便會報錯。
```rust
fn main() {
 let u1_name = String::from("Henry");
 let u1 = User {
 name: u1_name.as_str()
 };
 let u2;
 {
 let u2_name = String::from("Josh");
 u2 = User {
 name: u2_name.as_str()
 };
 }
 println!("{:?}", u2); // ERROR: `u2_name` does not live long enough
}
```
## Lifetime elision
並不是所有情況都必須顯式地指定生命週期，Rust 會根據規則嘗試 infer 生命週期，因此在很多情況下是可以省略的。規則被稱為 lifetime elision rules，有三項規則：
- compiler 會給是參考的參數一個生命週期。
- 如果剛好只有一個生命週期參數，Rust 會將該生命週期指定給回傳值。
- 如果有複數個生命週期參數，但其中一個是 `&self` 或 `&mut self`，Rust 會將該生命週期賦予回傳值。

在適用三項規則後仍無法確定回傳值的生命週期時，Rust 的 compiler 只好拋出錯誤，提示需要手動指定生命週期。

此時回到本篇第一段程式碼，`get_back_str` 函式沒有指定生命週期，Rust 嘗試以規則推導：
```rust
fn main() {
 let s1 = String::from("Hello");
 let s2 = String::from("World");
 let s = get_back_str(s1.as_str(), s2.as_str()); 
 // ERROR: missing lifetime specifier
 println!("{s}");
}

fn get_back_str(s1: &str, s2: &str) -> &str {
 s1
}
```
根據第一項規則推導後，函式是這個樣子的
```rust
fn get_back_str<'a, 'b>(s1: &'a str, s2: &'b str) -> &str
```
因為有兩個生命週期，第二項規則不適用，因為沒有 `&self` 這並非 method，也不適用第三項規則，此時 Rust 仍然無法推導回傳值的生命週期，因而拋出錯誤。

## static lifetime
Rust 一個特別的生命週期 `'static` (靜態生命週期)，表示存活在整個程式期間，這也是 string literal 的生命週期，因此 string literal 一直都會有效 (always available)。
```rust
let s: &'static str = "Hello";
```
此時來看看上面這段會報錯的程式：
```rust
fn main() {
 let s1 = String::from("Hello");
 let s;
 {
 let s2 = String::from("World");
 s = get_back_str(s1.as_str(), s2.as_str());
 }
 println!("{s}"); // ERROR: `s2` does not live long enough
}

fn get_back_str<'a>(s1: &'a str, s2: &'a str) -> &'a str {
 s1
}
```
若把 `s1` 和 `s2` 改成 string literal 的話，就不會報錯，顯見 `s2` 仍是有效的。
```rust
fn main() {
 let s1 = "Hello";
 let s;
 {
 let s2 = "World";
 s = get_back_str(s1, s2);
 }
 println!("{s}"); // Hello
}

fn get_back_str<'a>(s1: &'a str, s2: &'a str) -> &'a str {
 s1
}
```

Rust 學習筆記：生命週期

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 特徵 Traits
特徵用於定義共同行為，類似於某些語言中 interface 的用途，但有些不同。

## 定義
定義 trait 的寫法如下：
```rust
trait Greeting {
 fn say_hello(&self) -> String;
}
```
和 `impl` 區塊非常像，不過這邊不寫方法的實作，而是提供簽名 (signatures)，定義方法的名字、參數與回傳值。

## 實作
這邊是為 `struct` 實作 trait 的例子，在 `impl` 後面加上 `for` 以實作特徵。
```rust
trait Greeting {
 fn say_hello(&self) -> String;
}


struct Person {
 name: String
}

impl Greeting for Person {
 fn say_hello(&self) -> String {
 format!("Hello {}!", self.name)
 }
}

fn main() {
 let p1 = Person {
 name: String::from("Josh")
 };
 
 println!("{}", p1.say_hello()); // Hello Josh!
}

```
要注意的是實作必須包含所有 trait 所定義的簽名，否則會出現錯誤。
```rust
trait Greeting {
 fn say_hello(&self) -> String;
 fn say_goodbye(&self) -> String; // added
}

struct Person {
 name: String
}

impl Greeting for Person {
 fn say_hello(&self) -> String {
 format!("Hello {}!", self.name)
 }
}

// ERROR: not all trait items implemented, missing: `say_bye`
```
### 預設實作
在 trait block 中並非不能撰寫實作部分，寫在 trait 中的實作會被用為預設實作。
```rust
trait Greeting {
 fn say_hello(&self) -> String;
 fn say_goodbye(&self) -> String {
 String::from("Good bye!")
 }
}

struct Person {
 name: String
}

impl Greeting for Person {
 fn say_hello(&self) -> String {
 format!("Hello {}!", self.name)
 }
}

fn main() {
 let p1 = Person {
 name: String::from("Josh")
 };
 
 println!("{}", p1.say_goodbye()); // Good bye!
}
```
## 用 trait 定參數
我們可以利用 trait 來定義參數的型別為有實作特定 trait 的類型，寫為 `impl Trait` 如下。
```rust
fn print_hello(p: &impl Greeting) {
 println!("{}", p.say_hello());
}
```
上面可以改用 **trait bound** 的寫法寫成下面這樣，這在介紹到泛型時用過。
```rust
fn print_hello<T: Greeting>(p: &T) {
 println!("{}", p.say_hello());
}
```

## 進階使用
- 可以使用 `+` 來指定複數個 trait
- 使用 `where` 語法定義 trait bound，避免冗長的泛型定義

下面程式碼建立了兩個 struct，其中 `Person` 實作了 `Hello` 和 `Goodbye` trait，`P` 則只實作 `Hello`，利用上面兩個特性定義 `greeting` 函式。
```rust
struct Person {
 name: String
}

struct P {
 name: String
}

trait Hello {
 fn say_hello(&self) -> String {
 String::from("Hello!")
 }
}

trait Goodbye {
 fn say_goodbye(&self) -> String {
 String::from("Good bye!")
 }
}

impl Hello for Person {}
impl Goodbye for Person {}
impl Hello for P {}

fn greeting<T, U>(p1: &T, p2: &U)
where
 T: Hello + Goodbye,
 U: Hello
{
 println!("{}", p1.say_hello());
 println!("{}", p1.say_goodbye());
 
 println!("{}", p2.say_hello());
}

fn main() {
 let p1 = Person {
 name: String::from("Josh")
 };
 
 let p2 = P {
 name: String::from("Josh")
 };
 
 greeting(&p1, &p2);

 // output:
 // Hello!
 // Good bye!
 // Hello!
}

```

### 對所有有符合特徵的類型實作特徵
下面程式為有實作 `Hello` 的類型實作 `PrintHello` trait。
```rust
struct Person {
 name: String
}

trait Hello {
 fn say_hello(&self) -> String {
 String::from("Hello!")
 }
}

trait PrintHello {
 fn print_hello(&self);
}

impl Hello for Person {}
impl<T: Hello> PrintHello for T {
 fn print_hello(&self){
 println!("{}", self.say_hello());
 }
}

fn main() {
 let p1 = Person {
 name: String::from("Josh")
 };
 
 p1.print_hello(); // Hello!
}
```

## 寫在最後
泛型與特徵結合使用的技巧很多，這邊只有截選一些個人的筆記，掌握兩者並結合使用是減少程式碼重複的關鍵，也讓別人更易於使用自己寫的程式。

下一章是 Rust 中非常重要也非常不容易的 topic，生命週期 (lifetime)。

Rust 學習筆記：特徵

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 泛型
泛型允許我們寫程式時定義一些未來才會指定的類型，這能讓方法或資料類型更有彈性。

## function
如下所示，在不使用泛型的情況下，因為我們必須指定參數的類型，即使 function 內的程式邏輯幾乎完全相同我們也必須撰寫兩支 function。
```rust
fn main() {
 print_number(5); // 5
 print_str("My str"); // My str
}

fn print_number(num: i32){
 println!("{num}");
}

fn print_str(s: &str){
 println!("{s}");
}
```
可以用泛型簡化，泛型以 `<>` 定義，命名為 `T` 算是 naming convention，也可以自由命名。
```rust
use std::fmt::Display;

fn main() {
 my_print(5);
 my_print("My str");
}

fn my_print<T: Display>(content: T){
 println!("{content}");
}
```
要注意的是呼叫 `println!` 需要實作 `Display` trait，因此這邊將 T 限縮為有實作 `Display` trait 的類型，trait 在下一章就會學習到，這邊稍微看過即可。

## struct
struct 也可以使用泛型，這邊利用了複數個泛型讓 `S` 能夠儲存任意的資料類型。
```rust
#[derive(Debug)]
struct S<T, U> {
 a: T,
 b: U
}


fn main() {
 let x = S {
 a: String::from("test"),
 b: 15
 };
 
 let y = S {
 a: 1.5,
 b: vec![1, 2, 3]
 };
 
 println!("{:?}", x); // S { a: "test", b: 15 }
 println!("{:?}", y); // S { a: 1.5, b: [1, 2, 3] }
}
```

### impl
implementation block 中使用泛型實作方法的寫法如下，需要在 `impl` 後先定義泛型才能為 `S<T>` 實作方法。

```rust
use std::fmt::Display;

struct S<T> {
 a: T,
}

impl<T: Display> S<T>{
 fn print_a(&self){
 println!("{}", self.a);
 }
}


fn main() {
 let x = S {
 a: String::from("test")
 };
 
 x.print_a(); // test
}
```
如果將 a 設為為實作 `Display` trait 的類型但呼叫 `print_a` 則會報錯。
```rust
let y = S {
 a: vec![1, 2, 3]
};

y.print_a(); // ERROR
// the method `print_a` exists for struct `S<Vec<{integer}>>`, 
// but its trait bounds were not satisfied
```
也可以只為特定類型實作方法，下面程式只為 `i32` 實作 `print_a`。

```rust
struct S<T> {
 a: T,
}

impl S<i32>{
 fn print_a(&self){
 println!("{}", self.a);
 }
}

fn main() {
 let x = S {
 a: 5
 };
 
 let y = S {
 a: String::from("test")
 };
 
 x.print_a(); // 5
 y.print_a(); // ERROR
 // no method named `print_a` found for struct `S<String>` in the current scope
}
```

## enum
enum 中使用的泛型已經不陌生，常用的 `Option` 和 `Result` 其實都是以泛型實作。
```rust
enum Option<T> {
 Some(T),
 None,
}

enum Result<T, E> {
 Ok(T),
 Err(E),
}
```

Rust 學習筆記：泛型

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 錯誤處理
許多語言中處理錯誤是用 try / catch 或 except 這樣例外處理的方式，Rust 則使用相當不同的處理機制。

## panic
使用 `panic` macro 拋出一個錯誤，就如其名造成程式的「恐慌」離開程式。`panic` 適用於處理無法復原的錯誤。
```rust
fn main() {
 panic!("This is a error.");

 // thread 'main' panicked at src/main.rs:2:5:
 // This is a error.
}
```

## Result
使用 `Result` enum 處理可被復原的錯誤，在可能會出錯的方法中經常使用的回傳型別，比如說開啟檔案。

下面嘗試開啟一個不存在的檔案，`File::open` 回傳的 `Result` 有兩種 variant，`Ok` 或 `Err`，`Err` 便是代表錯誤。
```rust
use std::fs::File;

fn main() {
 let file = File::open("not-exist.txt");
 
 match file {
 Ok(file) => file,
 Err(err) => panic!("{:?}", err),
 };

 // Os { code: 2, kind: NotFound, message: "No such file or directory" }
}
```

### unwrap
`unwrap` 方法會直接在錯誤時 panic，是一種快速的寫法。
```rust
let file = File::open("not-exist.txt").unwrap();
// called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }
```

### expect
`expect` 則可以讓我們自訂錯誤訊息。
```rust
let file = File::open("not-exist.txt").expect("File not found");
// File not found: Os { code: 2, kind: NotFound, message: "No such file or directory" }
```

## 回傳錯誤
我們使用 `Result` 作為可能錯誤的方法的回傳值，這邊利用 `?` 運算子會在 `Err` 時直接 return 錯誤。
```rust
use std::fs::File;
use std::io;

fn main() {
 let file = open_file("not-exist.txt");
 
 match file {
 Ok(file) => file,
 Err(err) => panic!("{:?}", err),
 };

 // Os { code: 2, kind: NotFound, message: "No such file or directory" }
}

fn open_file(path: &str) -> Result<File, io::Error>{
 let a = File::open(path)?;
 Ok(a)
}
```
上面的程式相當於：
```rust
use std::fs::File;
use std::io;

fn main() {
 let file = open_file("not-exist.txt");
 
 match file {
 Ok(file) => file,
 Err(err) => panic!("{:?}", err)
 };

 // Os { code: 2, kind: NotFound, message: "No such file or directory" }
}

fn open_file(path: &str) -> Result<File, io::Error>{
 let a = File::open(path);
 
 match a {
 Ok(file) => Ok(file),
 Err(err) => Err(err)
 }
}
```

## 寫在最後
錯誤處理是很大的一項課題，選擇處理的方式與時機也是學問，The Book 中有一篇 [To panic! or Not to panic!](https://doc.rust-lang.org/book/ch09-03-to-panic-or-not-to-panic.html) 建議仔細閱讀。

Rust 學習筆記：錯誤處理

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
>     - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
>     - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 字串
字串在 Rust 中是相當複雜的，在 C 中字串只是一串 `char`，而在 Rust 中字串則有很多的表現形式，其中最常使用到的是 `String` 與 `&str`。

在 Rust 中字串與切片都是以 UTF-8 編碼的，通常情況我們並不需要擔心編碼的問題。

# String
String 並不是 Rust 核心中內建的型別，他是在 std library 中提供的型別，因為它太常使用到因此包含在 prelude 中，會被 Rust 自動導入我們不需要手動導入它。


## 創建
以 `new` 方法建立空字串，或以 `from` 給予初始值。
```rust
let mut s = String::new();
let from = String::from("from");
println!("{from}");                           // from
```
`to_string` 方法可將有 `Display` trait 的型別轉換為 String。
```rust
let number_string = 5.to_string();
let literal_string = "literal".to_string();
println!("{number_string}");                  // 5
println!("{literal_string}");                 // literal
```

## 更新
建立可變字串，`push` 新增字元進字串，或以 `push_str` 新增字串切片，
```rust
let mut s = String::from("Hello");
s.push(' ');
s.push_str("World.");
println!("{s}");                              // Hello World.
```
使用 `+` 運算子串接字串，`s2` 必須使用參考，`s1` 的所有權會被轉移到 `s3`。
```rust
let s1 = String::from("Hello ");
let s2 = String::from("world");
let s3 = s1 + &s2;

println!("{s3}");                             // Hello world
```
使用 `format` macro 更方便的串接字串格式，用法類似 `print`，`format` 使用的都是參考因此不會產生所有權的移轉。
```rust
let s1 = String::from("Hello ");
let s2 = String::from("new ");
let s3 = String::from("world");

let s = format!("{s1}{s2}{s3}");

println!("{s}");                              // Hello new world

// it's ok to use s1 s2 s3
println!("{s1}");
println!("{s2}");
println!("{s3}");
```

## 索引
Rust 不允許使用數字索引字串，因為 UTF-8 編碼每個字元的 byte 長度是不同的，會造成難以預期的結果，因此 Rust 不允許這樣的用法。

我們可以使用 `chars` 方法取回一個 iterator 來遍歷每個 char，這在英文不會有問題。
```rust
let s1 = String::from("Hello");
    
for char in s1.chars() {
    println!("{char}");
}

// output:
// H
// E
// L
// L
// O
```
但如過要使用其他語言可能會產生非預期的結果，如書上提供的印度語範例。
```rust
let s1 = String::from("नमस्ते");
    
for char in s1.chars() {
    print("{char} ");
}
// output: न म स ् त े 
```
這會印出六個數值，這是因為 `chars` 取得的是 `scalar values`，它不一定就是一般人認知的字母。

用另一種形式取得 `grapheme clusters` 會更接近一般人所認知的字母，這會需要引入 `unicode_segmentation` crate。
```rust
use unicode_segmentation::UnicodeSegmentation;

fn main() {
    let s1 = String::from("नमस्ते");
    
    for i in s1.graphemes(true) {
        print!("{i} ");
    }
}
// output: न म स् ते 
```
在使用切片時也會遇到類似的狀況，這邊我們必須給定 `0..3` 來取得 `न`。
```rust
let s1 = String::from("नमस्ते");
println!("{}", &s1[0..3]);      // न
```
總之在操作字串尤其非英文的語言時一定要留意這類情形。


Rust 學習筆記：字串

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 向量 Vector
vector 是和 array 類似的資料結構，差別在於 array 會在 stack 上配置記憶體因此必須為固定大小長度，vector 則會向 heap 配置記憶體，可以提供動態大小的元素集合，在多數情況會比 array 來得實用。

## 創建
使用 `new` 函式建立一個空 vector，注意我們必須給予 type annotation 明確指出型別。
```rust
let v1: Vec<i32> = Vec::new();
```
`vec!` macro 提供建立初始值的快捷方式。這種做法 Rust 能夠自行推導型別。
```rust
let v2 = vec![1, 2, 3];
```

## 新增
使用 `push` 在 vector 最後新增元素。注意必須使用 `mut` 讓 `v1` 可變
```rust
let mut v1 = vec![1, 2, 3];
v1.push(4);
println!("{:?}", v1); // [1, 2, 3, 4]
```
使用 `append` 可將一個 vector 接在後面 (move)，被移過去的 vector 則會清空。
```rust
let mut v1 = vec![1, 2, 3];
let mut v2 = vec![4, 5, 6];
v1.append(&mut v2);
println!("{:?}", v1); // [1, 2, 3, 4, 5, 6]
println!("{:?}", v2); // []
```

## 讀取
使用索引語法讀取元素。
```rust
let v1 = vec![1, 2, 3];
println!("{}", v1[1]); // 2
```
索引語法讀取超出 vector 的索引時會造成 panic。
```rust
let v1 = vec![1, 2, 3];
println!("{}", v1[5]); // index out of bounds: the len is 3 but the index is 5
```
不確定索引是否存在時，使用 `get` 可以取得 `Option<&T>` 回來做 pattern matching。
```rust
let v1 = vec![1, 2, 3];
 
if let Some(x) = v1.get(5) {
 println!("{}", x);
} else {
 println!("Not found");
}

// output: Not found
```

## 移除
使用 `pop` 移除最後一個元素，pop 會回傳一個 `Option` 帶有被移除的元素，若 vector 為空則為 `None`。
```rust
let mut v1 = vec![1, 2, 3, 4, 5];
 
match v1.pop() {
 Some(x) => println!("{} removed.", x), // 5 removed.
 _ => ()
}

println!("{:?}", v1); // [1, 2, 3, 4]
```
`remove` 可以在特定位置移除元素。
```rust
let mut v1 = vec![1, 2, 3, 4, 5];
 
v1.remove(2);

println!("{:?}", v1); // [1, 2, 4, 5]
```
因為 `remove` 會在移除後將後續元素全部往前 shift，因此 worst case 時間複雜度為 `O(n)`，如果不關心順序只是想移除某個元素時可以使用 `swap_remove` ，它會將最後一個元素移到被移除的位置，雖然順序會亂掉但時間複雜度為常數 `O(1)`。
```rust
let mut v1 = vec![1, 2, 3, 4, 5];
 
v1.swap_remove(2);

println!("{:?}", v1); // [1, 2, 5, 4]
```

## 遍歷
使用 `for` 遍歷 vector。
```rust
let v1 = vec![1, 2, 3];
 
for i in v1 {
 println!("{}", i);
}

// output: 
// 1
// 2
// 3
```

## 利用 enum 儲存不同型別資料
我們可以利用 enum 達成存入不同型別的資料的效果。
```rust
enum VT {
 String(String),
 Number(i32)
}

fn main() {
 let v1 = vec![VT::String(String::from("Hello")), VT::Number(5)];
 
 for i in v1 {
 match i {
 VT::String(v) => println!("String: {}", v),
 VT::Number(v) => println!("Number: {}", v)
 }
 }
}

// output:
// String: Hello
// Number: 5
```

# 雜湊表 HashMap
Map 是常見的 key-value pair 集合，Rust 中常用的 `HashMap` 定義在 standard library 中。

## 創建
要使用 `HashMap` 必須先引入，然後一樣使用 `new` 建立。

這邊建立一個 key 為 `String`、value 為 `i32` 的 HashMap。HashMap 的 key 必須為同一型別、value 也必須為同一型別。
```rust
use std::collections::HashMap;

fn main() {
 let m:HashMap<String, i32> = HashMap::new();
}
```
不是所有情況都必須要明確給定 type annotation，我們在建立後馬上 insert 一筆資料，Rust 能夠推導出其型別。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
```

## 新增、修改
要新增資料必須使用 `mut` 使其可變，使用 `insert` 進插入一筆資料。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
```
如果我們對同樣的 key 重複 insert，會將值覆蓋。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
m.insert(String::from("k1"), 100);
println!("{:?}", m); // {"k1": 100}
```

## 讀取
和 vector 相同我們可以使用 `get` 取得對應值。回傳的一樣是 `Option`。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
m.insert(String::from("k2"), 2);

if let Some(x) = m.get(&String::from("k2")){
 println!("{}", x);
} else {
 println!("Not found");
}

// output:
// 2
```

## 移除
`remove` 用於移除特定資料。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
m.remove(&String::from("k1"));
println!("{:?}", m); // {}
```

## 遍歷
使用 `for` 對雜湊進行遍歷，要注意的是順序是不定的，每次執行順序可能不同。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
m.insert(String::from("k2"), 2);

for (key, value) in &m {
 println!("{}: {}", key, value);
}

// output:
// k2: 2
// k1: 1
```

## entry
一個實用的方法 `entry`，回傳一個 `Entry` enum，`Occupied` 代表已經被占用(key已經存在)，`Vacant` 則是還不存在。

`entry` 很適合用於要對 key 存在與否做不同處理時，以下程式若 key 已存在則將值+1，不存在則插入 1。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);

match m.entry(String::from("k1")) {
 Entry::Occupied(mut e) => *e.get_mut() += 1,
 Entry::Vacant(e) => {
 e.insert(1);
 }
}

println!("{:?}", m); // {"k1": 2}
```
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);

match m.entry(String::from("k1100")) {
 Entry::Occupied(mut e) => *e.get_mut() += 1,
 Entry::Vacant(e) => {
 e.insert(1);
 }
}

println!("{:?}", m); // {"k1": 1, "k1100": 1}
```
有一個常用的便利方法 `or_insert`，可以只在 key 不存在時插入，避免使用 `insert` 會直接覆蓋。
```rust
let mut m = HashMap::new();
m.insert(String::from("k1"), 1);
m.entry(String::from("k1")).or_insert(100);
println!("{:?}", m); // {"k1": 1}
```
### BTreeMap
[BTreeMap](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html)

std library 中有另一種 Map `BTreeMap`，不同於雜湊其使用 B 樹實作，相對於 `HashMap` 增刪讀取都是常數時間，`BTreeMap` 都需要對數時間，但它有額外提供一些功能且是有序的。

雖然目前我多數情況使用 `HashMap` 即可，但多認識 `BTreeMap` 也不錯，當需要的時候也知道有這項工具能夠使用。

下一篇會進入應該是最常使用的集合，字串 `String`。

Rust 學習筆記：向量與雜湊表

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 列舉 Enums
enum 定義的是可能的一組特定數值，以下定義一組顏色。
```rust
enum Color {
 Green,
 Red,
 Blue
}

struct Tag {
 name: String,
 color: Color
}
```
使用時則是使用 `::` 來取得特定顏色。
```rust
let tag1 = Tag {
 name: String::from("new"),
 color: Color::Blue
};
```
enum 中的 variants 也能夠擁有數值，以下讓 `Color` 都能有擁有一個 `String`。
```rust
enum Color {
 Green(String),
 Red(String),
 Blue(String)
}

fn main() {
 let c1 = Color::Blue(String::from("Blue"));
}
```
這種做法可以讓 enum 中不同的 variant 有不同的值。
```rust
enum Color {
 Green(String),
 Red(i32),
 Blue(f64)
}

fn main() {
 let c1 = Color::Green(String::from("Blue"));
 let c2 = Color::Red(5);
 let c3 = Color::Blue(1.0);
}
```
enum 像 struct 一樣可以有 impl block 定義 methods。
```rust
#[derive(Debug)]
enum Color {
 Green(String),
 Red(String),
 Blue(String)
}

impl Color {
 fn print(&self) {
 println!("{:?}", self)
 }
}

fn main() {
 let c1 = Color::Blue(String::from("Blue"));
 c1.print(); // Blue("Blue")
}
```
## Option
`Option` 是一種內建在 Rust 的 standard library 的 enum，他是 Rust 處理值可能為空值的解決方案，因為 Rust 不像其他許多語言有空值的型別，如 Javascript 的 `null` 或 `undefined。`

以下是 `Option` 的定義：
```rust
enum Option<T> {
 None,
 Some(T),
}
```
看起來非常的 self explained，Option 代表的是可能為空 `None`、或可能有某些數值 `Some(T)`。這邊的 T 是 generic，也就是泛型，之後會學習到。

## Result
還有另一種特定的 enum 叫做 `Result`，與 `Option` 有些類似，這是他的定義：
```rust
enum Result<T, E> {
 Ok(T),
 Err(E),
}
```
在某些可能會失敗的函式中會使用 `Result` 作為回傳值 (比如讀取檔案)，讓我們 handle success 和 error case。

# 模式配對 Pattern matching
Pattern matching 是讓 Rust 的 enum 真正強大的地方，它是一種流程控制，有點像其他語言中的 switch case。

下面的程式是一個簡短的 pattern matching 的範例，我們使用 `match` 進行 pattern matching，為每個 variant 配對一段 expression，`l` 在進入 `match` 之後比對各個 variant 然後執行配對到的程式。
```rust
enum Language {
 Chinese,
 English,
 Japanese
}

fn main() {
 let l = Language::Japanese;
 
 match l {
 Language::Chinese => println!("你好"),
 Language::English => println!("Hello"),
 Language::Japanese => println!("こんにちは")
 }; 

 // output: こんにちは
}
```
當 enum 有綁定值時可以使用以下方式取得值。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 match l {
 Language::Chinese(s) => println!("你好 {}", s),
 Language::English(s) => println!("Hello {}", s),
 Language::Japanese(s) => println!("こんにちは {}", s)
 };

 // output: Hello Josh
}
```
pattern matching 必須涵蓋所有可能的 variant，若有缺少會直接報錯。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 match l {
 Language::Chinese(s) => println!("你好 {}", s),
 Language::English(s) => println!("Hello {}", s),
 };

 // ERROR: non-exhaustive patterns: `Language::Japanese(_)` not covered
}
```
如果只關心部分的可能性，又不想把全部列出來，可以使用 `other` 變數做 catch-all 的操作。
```rust
#[derive(Debug)]
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 match l {
 Language::Chinese(s) => println!("你好 {}", s),
 other => println!("{:?}", other)
 };

 // output: English("Josh")
}
```
如果也不需要取得變數，可以用 `_` 替代 `other`。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 match l {
 Language::Chinese(s) => println!("你好 {}", s),
 _ => println!("Hello")
 };
}
```
甚至如果只關心部分的可能而其他想要直接忽略，可以用空的 tuple `()`，這樣就什麼都不會發生。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 match l {
 Language::Chinese(s) => println!("你好 {}", s),
 _ => ()
 };
}
```
像上面這種情況可以用 `if let` 語法做更精簡的改寫。

### if let
當我們只關心其中一種情況，其他所有情況都想忽略時，`if let` 語法提供了更簡單的寫法。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::English(String::from("Josh"));
 
 if let Language::English(s) = l {
 println!("Hello {}", s);
 }

 // output: Hello Josh
}
```
就像單純的 `if` 一樣，`if let` 也可以加上 `else` 區塊，就相當於 pattern matching 中 `_` 的區塊。
```rust
enum Language {
 Chinese(String),
 English(String),
 Japanese(String)
}

fn main() {
 let l = Language::Chinese(String::from("Josh"));
 
 if let Language::English(s) = l {
 println!("Hello {}", s);
 } else {
 println!("Hello world!");
 }

 // // output: Hello world!
}
```
## 寫在最後
[The book 中下一章](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html)是關於套件管理、程式碼拆分與管理專案結構，這部分很重要不過我習慣在實戰中慢慢邊參考邊練習，這邊稍微去閱讀就好，筆記會跳過這章下一篇直接進入集合。

Rust 學習筆記：列舉與模式配對

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
>     - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
>     - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 結構體 struct
Rust 並不像 C++ 或 Java 提供物件導向的 `class` 語法，Rust 中使用 `struct` 或 `enum` 配合 `impl` 區塊來自定義類型結構與 method，這篇先來學習 `struct`。

### struct 定義
定義 struct 的語法如下。
```rust
struct Person {
    name: String,
    height: u32,
    weight: u32
}
```
在 main function 裡建立一個 `Person` 的 instance，給定 key-value pair，這邊使用了 `derive` 給了 `Person` Debug trait，這個 concept 後面會學習到，在這邊只是用來讓我可以把 struct print 出來而已。
```rust
#[derive(Debug)]
struct Person {
    name: String,
    height: u32,
    weight: u32
}

fn main() {
    let p = Person {
        name: String::from("Josh"),
        height: 180,
        weight: 80
    };
    
    println!("{:?}", p);    // Person { name: "Josh", height: 180, weight: 80 }
}

```

### 取得 struct 中的值
可以用 dot notation 來取用 struct instance 中的值。
```rust
println!("{}", p.name);     // Josh
```

### 可變結構
一樣可以用 `mut` 讓 struct 可變，要注意的是 struct 必須是整個可變，我們不能僅讓其中一個 field 可變。
```rust
let mut p = Person{
        name: String::from("Josh"),
        height: 180,
        weight: 80
    };
    
println!("{}", p.height);       // 180

p.height += 10;

println!("{}", p.height);       // 190
```

### Struct Update Syntax
在 Rust 中可以運用所謂的 Struct Update Syntax 來利用存在的 instance 來建立新的 instance，並保留其部分設定值。語法為使用 `..`。

學過 Javascript 的看起來會感覺很像 spread operator 的用法。
```rust
let p = Person{
    name: String::from("Josh"),
    height: 180,
    weight: 80
};

let p2 = Person {
    name: String::from("Peter"),
    ..p
};

println!("{:?}", p);        // Person { name: "Josh", height: 180, weight: 80 }
println!("{:?}", p2);       // Person { name: "Peter", height: 180, weight: 80 }
```

### Tuple structs 
struct 也可以沒有 key，看起來會很像 tuple，主要用途在於為結構命名。
```rust
struct Point(i32, i32, i32);
```

### Unit-like structs
struct 也可以完全沒有欄位，很像 unit type `()`。
```rust
struct Unit; 
```

## 實作 method
我們使用 `impl` 來建立 Person 的 implementation block，在裡面可以實作 method。
```rust
struct Person {
    name: String,
    height: u32,
    weight: u32
}

impl Person {
    fn print_name(&self) {
        println!("{}", self.name);
    }
}

fn main() {
    let p = Person{
        name: String::from("Josh"),
        height: 180,
        weight: 80
    };
    
    p.print_name();     // Josh
}
```

這邊的 `&self` 是 `self: &self` 的簡寫，method 的第一個參數必須是名為 `self` 的 `Self` 型別。

`self` 也不一定需要是參考，在部分情況需要時一樣可以不使用參考而取得 `self` 的所有權。



在 impl block 中可以實作複數個 method，這邊再寫一個計算 bmi 的 method。
```rust
struct Person {
    name: String,
    height: u32,
    weight: u32
}

impl Person {
    fn print_name(&self) {
        println!("{}", self.name);
    }
    
    fn get_bmi(&self) -> f64 {
        let h = ((self.height as f64) / 100.0) * ((self.height as f64) / 100.0);
        (self.weight as f64) / h
    }
}



fn main() {
    let p = Person{
        name: String::from("Josh"),
        height: 180,
        weight: 80
    };
    
    println!("{:?}", p.get_bmi());      // 24.691358024691358
}

```

## Associated Functions
若不需要自己的 instance 的話，可以撰寫第一個參數不是 self 的 function，這種 function 在 Rust 中被稱為 **Associated Functions**，他們不被稱作 methods，因此我們才會說 method 的第一個參數必須是名為 `self` 的 `Self` 型別。

struct 可以用複數個 impl block，這裡我就分開一個 block。
```rust
struct Person {
    name: String,
    height: u32,
    weight: u32
}

impl Person {
    fn print_name(&self) {
        println!("{}", self.name);
    }
    
    fn get_bmi(&self) -> f64 {
        let h = ((self.height as f64) / 100.0) * ((self.height as f64) / 100.0);
        (self.weight as f64) / h
    }
}

impl Person {
    // Associated Function
    fn say_hello() {
        println!("{}", "Hello");
    }
}

fn main() {
    let p = Person{
        name: String::from("Josh"),
        height: 180,
        weight: 80
    };
    
    Person::say_hello();        // Hello
    
    println!("{:?}", p.get_bmi());
}
```
使用 Associated Function 的語法是 `::`，我們在建立 `String` 時使用 `From` 經常用到。

事實上這也是 Associated Function 最常見的 use case，用來產生新的 struct instance。

我們可以為 `Person` 實作 `new` function 來建立新的 instance。
```rust
#[derive(Debug)]
struct Person {
    name: String,
    height: u32,
    weight: u32
}

impl Person {
    fn print_name(&self) {
        println!("{}", self.name);
    }
    
    fn get_bmi(&self) -> f64 {
        let h = ((self.height as f64) / 100.0) * ((self.height as f64) / 100.0);
        (self.weight as f64) / h
    }
}

impl Person {
    // Associated Functions
    fn say_hello() {
        println!("{}", "Hello");
    }
    
    fn new(name: String, height: u32, weight: u32) -> Person {
        Person { name, height, weight }
    }
}

fn main() {
    let p = Person::new(String::from("Josh"), 180u32, 80u32);
    println!("{:?}", p);        // Person { name: "Josh", height: 180, weight: 80 }
}
```
是不是更像建立 `String` 的用法了 ?

這邊還用到了一個特性，在 key 和 value 同名時可以省略，而不需要寫成 `name: name`，這如果是寫過 Javascript 的應該會很熟悉這個方便的寫法。
```rust
fn new(name: String, height: u32, weight: u32) -> Person {
    Person { name, height, weight }
}
```

下一篇會進入 `enum` 囉。


Rust 學習筆記：結構體

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
>     - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
>     - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 參考

> A reference is like a pointer in that it’s an address we can follow to access the data stored at that address;

在 Rust 中參考就像是 pointer，和 pointer 的差異是在 Rust 中參考保證值是 valid 的。

參考以下程式，`say_hello` 接受一個 `name` 參數，print 出結果。這是我們以往的作法：
```rust
fn main() {
    let s = String::from("Josh");
    
    say_hello(s);
    
    println!("{}", s); // ERROR: borrow of moved value: `s`
}

fn say_hello(name: String){
    println!("Hello {}!", name);
}
```
這邊會發現若我們在後面要繼續使用 `s` 會出現報錯，因為 `s` 在傳入函式時產生了所有權的移轉。若我們要再次使用會需要在函式中把 s 再 return 出來，即把所有權轉移回來。

另一種方式是使用參考，寫法是以 `&` prefix：
```rust
fn main() {
    let s = String::from("Josh");
    
    say_hello(&s);  // Hello Josh!
    
    println!("{}", s);  // Josh
}

fn say_hello(name: &String){
    println!("Hello {}!", name);
}
```
利用參考不產生所有權移轉，因此我們即使不做回傳也能在 main 中繼續使用 `s`。

## 可變參考
參考與值一樣預設是不可變的，一樣可以利用 `&mut` 讓其可變。

```rust
let mut s = String::from("Josh");
let s1 = &s;

s1.push('1');     // cannot borrow `*s1` as mutable, as it is behind a `&` reference

println!("{}", s1);
```

```rust
let mut s = String::from("Josh");
let s1 = &mut s;

s1.push('1');

println!("{}", s1);     // Josh1
```

## 參考的規則
- 同時只能有無限的不可變參考，或一個可變參考。
- 參考必須永遠合法 (valid)

### 不可變參考數量不限
```rust
let mut s = String::from("Josh");
let s1 = &s;
let s2 = &s;

println!("{}", s1);     // Josh
println!("{}", s2);     // Josh
```

### 可變參考只能有一個
```rust
let mut s = String::from("Josh");
let s1 = &mut s;
let s2 = &mut s;

println!("{}", s1);     // ERROR: cannot borrow `s` as mutable more than once at a time
println!("{}", s2);
```

### 不可同時有不可變參考與可變參考
```rust
let mut s = String::from("Josh");
let s1 = &s;
let s2 = &mut s;

println!("{}", s1);
println!("{}", s2);     // ERROR: cannot borrow `s` as mutable because it is also borrowed as immutable
```

## 迷途指標 dangling pointer
Rust 中會保證參考的合法性，產生迷途指標會直接報錯。

以下是簡單的範例程式，在 `get_dangling_pointer` 我們 return `s` 的參考，然而我們知道 s 在函式結束後便被釋放，我們回傳的參考便指向一個已經被釋放的東西上，即為迷途指標。

Rust 在這種情況給出的錯誤訊息為 missing lifetime specifier，涉及到之後會學習的 lifetime。
```rust
fn main() {
    let s = get_dangling_pointer();     // missing lifetime specifier
}

fn get_dangling_pointer() -> &String {
    let s = String::from("Josh");
    &s
}
```

# 切片 Slice
看了上述的迷途指標，顯然我們無法在函式內建立新的 String 將其回傳。

切片型別便是一種解決方案，字串切片是字串某一段部分的參考。

不只字串有切片型別，

```rust
let s = String::from("Hello Josh");
let hello = &s[0..5];
println!("{}", hello); // Hello
```

使用 `[..]` 語法指定一段範圍，若以字串開頭為起始則 0 可省略，以字串末尾為結束則最後的 index 可省略。

```rust
let s = String::from("Hello");
println!("{}", &s[1..4]);   // ell

println!("{}", &s[0..5]);   // Hello
println!("{}", &s[..5]);    // Hello
println!("{}", &s[0..]);    // Hello
println!("{}", &s[..]);    // Hello
```

##  String literal 
string literal 的型別為字串切片 `&str`。
```rust
let s: &str = "Hello";
```

## 切片作為參數
以字串切片作為參數會比 `&String` 更具彈性，同時能夠接受切片與字串參考。
```rust
fn main() {
    let name_string = String::from("Josh");
    let name_slice = &name_string[..];
    
    say_hello(&name_string);    // OK: Hello Josh
    say_hello(name_slice);      // OK: Hello Josh
}

fn say_hello(name: &str){
    println!("Hello {}", name);
}
```
```rust
fn main() {
    let name_string = String::from("Josh");
    let name_slice = &name_string[..];
    
    say_hello(&name_string);    // OK: Hello Josh
    say_hello(name_slice);      // ERROR: mismatched types
}

fn say_hello(name: &String){
    println!("Hello {}", name);
}
```

## 切片作為回傳值
有了切片我們有回傳一部分字串的方法了。

下面程式回傳字串的前半段。
```rust
fn main() {
    let s = "I am handsome";
    
    let first_half = get_first_half(s);
    
    println!("{}", first_half);     // I am h
}

fn get_first_half(s: &str)->&str{
    &s[..s.len() / 2]
}
```

Rust 學習筆記：參考與切片

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
>     - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
>     - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 所有權 Ownership
所有權是 Rust 這門語言最重要的特色，也是 Rust 能做到 memory safety 的核心。理解所有權對學習 Rust 至關重要，但其特殊性又是 Rust 的學習曲線陡峭的原因之一。

## 記憶體使用
要理解所有權，首先就要把計概學過的觀念拿出來複習 XD，程式在使用記憶體時會使用到兩種資料結構，堆疊(stack)與堆積(heap)，因為我覺得他們的中文很容易混淆我習慣還是使用英文。

關於 stack 跟 heap 的概念大學的計概或資料結構課程都會詳細學習，沒有學過的可以往這方面去學習我就不說明了。

簡單來說
- 要推入 stack 的資料必須是 fixed size，且在 compile time 已知大小。
- dynamic size 的資料必須存入 heap，memory allocator 配置記憶體空間後會回傳 pointer，stack 上只會儲存 pointer 與一些 metadata (length, size..)

因為配置在 heap 上的資料(或記憶體空間) 不會和 stack 中的資料一樣在函式結束後 pop 出去，如何追蹤 heap 上的資料控制何時應該釋放記憶體空間就是程式語言需要處理的課題。

在許多內建 garbage collector 的語言中 (通常是高階語言)，GC 會自行去追蹤並釋放記憶體空間，對開發者來說是最方便的，不需要去煩惱記憶體的問題，但也會有效能較差、無法自己控制記憶體的缺點，GC 的存在也讓程式顯得笨重。

另一種方式是全權交給開發者自行控制 (如 C)，最基礎的用法要在需要配置記憶體時手動 `malloc` 一塊記憶體，並且在使用完畢後 `free` 釋放掉記憶體空間，這樣完全手動控制雖然能夠做到最佳化，卻又讓開發時間相應增加，另一方面也提高使用的難度，容易自己寫出問題。

Rust 的 Ownership 是管理記憶體的另一套方案，降低自己把程式寫壞的機率卻又不用 GC，其基本概念是遵循一套規則由 Rust 自動進行 memory 的配置與釋放，雖然不用手動管理記憶體但學習難度仍然不低，這套規則會讓撰寫時受到許多限制，這也是學習 Rust 的必經之路。

## Copy vs. Move
下面是一段簡單的程式，也很容易理解，將 `x` 這個 integer 賦值給了 `y`，這邊做的是一份 copy，`x` 和 `y` 都有一份整數 `5`。
```rust
let x = 5;
let y = x;
println!("{}", x);  // 5
println!("{}", y);  // 5
```
到了 String 這樣大小不定的東西行為就不同了，String 的值需要儲存在 heap 上。賦值時只會 copy 一份指向 heap 上 String 的參考，而不會將整個 String 的資料複製過來。

然而運行下面的程式會發現報錯，這邊我們透過 error message 看到兩個新的概念， borrow 以及 move。
```rust
let s1 = String::from("test");
let s2 = s1;
println!("{}", s1);     // ERROR: borrow of moved value: `s1`
println!("{}", s2);  
```

### Move
在我們將 `s1` 賦值給 `s2` 時我們 copy 的是參考，這邊還算好理解，特別的是在 copy 的同時 Rust 會將 `s1` 的變數無效化，我們便不再能夠使用 `s1`，這個行為稱為 **Move**，其目的在於確保 memory safety。

### Borrow
> We call the action of creating a reference borrowing.

Borrow 的概念不難理解，顧名思義，借用並不會發生所有權的移轉，建立參考的行為在 Rust 中被稱為 borrowing。

回到上面的程式，`s1` 被移動到了 `s2`，在我們將它傳入函式時，因為 `s1` 已經被無效化，因此我們無法再借用 `s1`。

## 所有權規則
> First, let’s take a look at the ownership rules. Keep these rules in mind as we work through the examples that illustrate them:
> - Each value in Rust has an owner.
> - There can only be one owner at a time.
> - When the owner goes out of scope, the value will be dropped.

[Ownership Rules](https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html#ownership-rules)

到這邊我們可以總結所有權的規則，The Book 的規則如上。

我簡單的理解就是「每個值都會有且同時只有一個 owner，值會在離開作用域後被 drop 掉」。

## 函式
有關函式傳參的行為和賦值類似，會產生所有權的變動，函式可以利用回傳值進行所有權的返還或賦予。

另一種方式是使用參考，不涉及所有權的變動，會在之後的章節學習。

Rust 學習筆記：所有權

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
> - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
> - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 流程控制
接續上篇，本篇進入流程控制，即條件判斷與迴圈。
## 條件判斷
Rust 中基本的條件判斷 if-else 寫法如下，condition 的部分並不加括號。
```rust
let x = 1;
 
if x == 0 {
 println!("x is 0.");
} else if x > 0 {
 println!("x is greater than 0.");
} else {
 println!("x is less than 0.");
}
```
利用 block scope 會回傳最後一行 expression 的特性，可以這樣用於賦值，得到結構上類似其他語言 ternary operation 的寫法。
```rust
let x = 1;
let y = if x == 0 { "equal" } else { "not equal" };
println!("{}", y); // not equal
```
## 迴圈
Rust 提供三種迴圈的寫法。
### loop
最基礎的 loop 迴圈，沒有終止條件，需要在內部使用 `break` 終止迴圈。以下程式只會執行一次後便停止。
```rust
loop {
 println!("again");
 break;
}
```
Rust 中的 loop 是可以回傳值的，在 `break` 後放上要回傳的值。
```rust
let mut counter = 0;
let five = loop {
 if counter == 5 {
 break counter;
 }
 counter += 1;
};
println!("{}", five); // 5
```
Rust 中的 loop 是可以加上 label 的，提供跳出巢狀迴圈的可能，甚至可以用它做到一些類似 `goto` 的操作，不過個人不是很喜歡這種用法就不提了 XD。

### while
`while` loop 就是附帶終止條件的迴圈，不過 Rust 是沒有 `do-while` loop 的，不過這也不是什麼問題很多語言都不會有，基本上用基本的迴圈就能達成。
```rust
let mut count = 0;

while count <= 5 {
 print!("{}", count);

 count += 1;
}

// 012345
```
### for
Rust 提供 `for` loop，尤其在遍歷陣列 (或其他 iterable) 時非常實用。
```rust
// loop over array elements
let arr = [10, 20, 30, 40, 50];
for item in arr {
 println!("{item}");
}

// loop over string chars
let my_string = "hello world";
for char in my_string.chars() {
 println!("{char}");
}

// loop over a range
for number in (1..10) {
 println!("{number}");
}
```

Rust 學習筆記：一般程式概念（下）

## 前言
本系列文書寫我個人初探 Rust 的學習筆記，章節劃分主要基於著名的 **The Book**，[The Rust Programming Language](https://github.com/rust-lang/book)，程式碼部分通常是個人閱讀消化後以方便說明的方式撰寫，完整學習建議直接參見該書。

> #### The Rust Programming Language
> - [Link](https://doc.rust-lang.org/stable/book/)
> - [Github](https://github.com/rust-lang/book)
>     - [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
>     - [MIT license](https://opensource.org/license/mit/)

該書也有中文翻譯版，不過個人閱讀以英文原版為主以鞏固對 terminology 的一致認識，我認為對未來閱讀以及查找資料會較為順暢。

不論語言該書都是相當優秀的學習資源，選擇適合你的語言開始學習 Rust 吧。

[Appendix F: Translations of the Book](https://doc.rust-lang.org/book/appendix-06-translation.html)

# 變數 (Variables)

在 Rust 中變數以 `let` 進行宣告，如果學習過 Javascript 的人應該會感到非常熟悉。
```rust
let x = "Hello world";
```
要注意的是 Rust 中變數預設是不可變的 (immutable)，因此如果執行下列程式會出現錯誤。
```rust
let x = "Hello world";
x = "Hi world";    // ERROR: cannot assign twice to immutable variable `x`
```
若要讓變數成為可變的變數，可以利用 `mut` keyword。
```rust
let mut x = "Hello world";
x = "Hi world";    // OK
```
### Const
在 Rust 中常數以 `const` 宣告。與 `let` 不同的是 `const` 無法使用 `mut` 讓其可變，`const` 應該永遠是不可變的。同時 `const` 要在宣告時給予型別，不像 `let` 會進行推論。

常數的 naming convention 為全大寫的 snake case。
```rust
const FIRST_CONST: i32 = 0;
const mut SECOND_CONST: i32 = 1;    // ERROR: const globals cannot be mutable
```
### Shadowing
可以利用宣告相同的變數名稱在當前 scope 中進行 shadowing。
```rust
let a = 0;
let a = 6;
println!("{}", a);  // 6
let a = "Hello";
println!("{}", a);  // Hello
```
#### 與 mut 的差別
利用 mut 宣告可變變數後，變數的型別仍然是不可變的，但我們可以使用 shadowing 將相同變數名稱宣告為不同型別的變數。

# 型別 Types
Rust 是靜態型別語言，釐清型別至關重要。
## Scalar Types
Scalar Types 代表單一值，Rust 中有四種主要的 Scalar Types。
- Integer 整數
- Float 浮點數
- Boolean 布林值
- Character 字元

各種類型的詳細可見 [Data Types](https://doc.rust-lang.org/book/ch03-02-data-types.html)，學過計概的人應該都不陌生我想就不再贅述。

Rust 預設的整數型別為 `i32` 即有號 32 位元整數，浮點數則為 `f64` 即雙精度浮點數。

## Compound Types
Compound Types 是一組複數值，Rust 有兩種原始 compound type，tuple (元組) 與 array (陣列)。

### Tuple 元組
tuple 可以含有不同型別，其具有固定長度。可以利用 destructure 解構讀取其值。
```rust
let tup = ("hello", "world", 5);
let (x, y, z) = tup;
println!("{}", x);  // hello
```
也可以用 dot notation 讀取。
```rust
println!("{}", tup.1);  // world
```

### Array 陣列
陣列中元素的型別必須是一樣的，以中括號表示。
```rust
let arr = [10, 20, 30, 40, 50];
```
另一種宣告法，可以利用這種方式建立陣列並填充相同元素的陣列，以下則為建立一個內含 10 個 10 的陣列。
```rust
let arr = [10; 10];
```
和多數程式語言一樣，利用 index assign 和 read 陣列元素。若要 assign 陣列元素需要宣告 mutable array。
```rust
let mut arr = [0; 10];
println!("{}", arr[5]);     // 0
arr[5] = 10;
println!("{}", arr[5]);     // 10
```

# 函式 Functions
在 Rust 中我們用 `fn` 建立函式。
```rust
fn main() {
    say_hello();    // Hello
}

fn say_hello() {
    println!("Hello");
}
```
我們可以宣告函式參數，這邊給 `say_hello` 一個參數，類型為 `&str`，這是字串的 slice 以 reference 的形式傳入，在後面的章節會有詳細學習。
```rust
fn main() {
    say_hello("Josh");  // Hello Josh
}

fn say_hello(name: &str) {
    println!("Hello {}", name);
}
```
### returning value
使用單箭頭號 `->` 宣告回傳值的型別，我們可以利用 `return` 將值回傳。
```rust
fn main() {
    let result = sum(5, 6);
    println!("{}", result);     // 11
}

fn sum(a: i32, b: i32) -> i32 {
    let sum = a + b;
    return sum;
}
```
Rust 能使用最後一行的 expression 進行回傳而不使用 `return`，因此上述的程式可以簡化為如下:
```rust
fn main() {
    let result = sum(5, 6);
    println!("{}", result);     // 11
}

fn sum(a: i32, b: i32) -> i32 {
    a + b
}
```
注意上面的 `a + b` 不能加上分號，否則會變成沒有任何回傳值的 statement，函式將會報錯回傳值與宣告不匹配。

補充: [Statements and Expressions](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html#statements-and-expressions)

## 寫在最後
本來想一篇寫完這個章節，不過後面還有不少篇幅，流程控制我就留到下篇再寫囉。

Rust 學習筆記：一般程式概念（上）

![archlinux neofetch](neofetch.png)
從來不打算嘗試 Arch 的我，今天是我第一天使用 Arch。

## 前言

作為一個 Linux 用戶，我在主要工作電腦上跑的是 Windows + Fedora 的雙系統，在跳到 Fedora 之前我用的都是 Ubuntu 或是基於 Ubuntu 的發行版，現在我對 Fedora 的日常使用表現還算滿意，雖然真的還是很多坑。

主要的問題是筆電系統，好幾年前的文書筆電，原先一直跑的是 Pop!\_OS，整體使用還算穩定，雖然前陣子發生過一次整台磚掉只好整個重灌過。

這陣子決定換個系統，順便改用 XFCE，一開始選上了 Manjaro，雖然是 Arch based 但 Manjaro 和 Arch 還是有不小的差距，用慣 Fedora (GNOME) 的我一進去覺得好亂，雖然 XFCE 在這台爛筆電上跑得確實比 GNOME 順暢，用了兩天後還是對 Manjaro 的體驗不太滿意，於是就決定來嘗試真正的 Arch Linux 了。

 

## 實戰 Arch Linux

#### 安裝

在 2022 安裝 Arch 其實並不如想像中複雜，甚至有許多自動化腳本可以使用，不過既然我是第一次那當然跟著 ArchWiki 的 [Installation guide (正體中文) - ArchWiki](<https://wiki.archlinux.org/title/Installation_guide_(%E6%AD%A3%E9%AB%94%E4%B8%AD%E6%96%87)>) 跑過一次囉。

Boot Loader 使用 GRUB，ArchWiki 也有詳盡說明 [GRUB - ArchWiki](https://wiki.archlinux.org/title/GRUB)，遇到一個問題是跑 `grub-install` 時如果沒有加 `--removable` 我的筆電會找不到他。

 

#### 安裝後

安裝後的 post-install tasks 我沒有記錄我到底做了哪些，只能憑印象了。

可以看 [General recommendations - ArchWiki](https://wiki.archlinux.org/title/general_recommendations) 的建議完成自己的系統設置，

我最主要的應該就是裝好 GUI，我選擇 Xorg 搭配 XFCE 桌面環境。
再來就是設置音訊驅動、顯卡驅動、中文介面與字體、防火牆、SSD Trim、中文輸入法、AUR(yay)、ffmpegthumbnailer、file-roller，然後調整 XFCE 的主題與外觀。
接著就是有需求再安裝設定相應的東西了。

 

## 結論

Arch Linux 從開始安裝到整個系統設置到我的日常使用環境比我想像中的容易許多，沒有遇到什麼問題非常順暢，應該比 Fedora 還順，第一次裝 Fedora 的時候我真的遇到一堆坑。

乾淨的系統真的很得我心，第一天我對 Arch 非常滿意，在筆電上試用一段時間如果沒什麼問題我大概要認真考慮在桌機上裝 Arch with KDE Plasma 了。

使用 Arch Linux 的第一天

[Fedora](https://getfedora.org/en/) 
I use Fedora 36 for this post. 
 
Recently I switched from Pop!\_OS to Fedora on my desktop. I found that there are a lot of things to check or configure after the installation. 
Every distro do things differently. Although I'm not a big fan of distro-hopping, it's still a good idea to list all the post-installation steps I go through.

#### My setup

![neofetch](neofetch.png)

## About Installation

Most of the popular distros for desktops today provides a nice installation GUI, just walk through the process. 
Fedora even provides a nice Fedora Media Writer, makes it super easy. You no longer need application like [Rufus](https://rufus.ie/) or [balenaEtcher](https://www.balena.io/etcher/) to create bootable USB drive. The Fedora Media Writer will handle it for you. 
 
**Note:** If CSM is enabled in BIOS, the auto partition will install it with legacy mode in my experience. I have to re-install it to use UEFI...
Make sure to turn off CSM or do the disk partition by yourself to create a ESP.

## Thing to do after installation

### 1. Keep everything up to date

```bash
$ sudo dnf update
```

Fedora 36 uses DNF as it's software package manager. Simply run the update command to update the system.

#### Speed up DNF

To increase the download speed of DNF, there are some configuration we can set in the configuration file located at `/etc/dnf/dnf.conf`. 
I use the following settings to make DNF to select fastest mirror and enable parallel downloads up to 10.

```
fastestmirror=True
max_parallel_downloads=10
```

I also set keepcache to True for the first update since there are so many packages to update.

```
keepcache=True
```

### 2. Getting more softwares and packages

#### RPM Fusion

[rpmfusion.org](https://rpmfusion.org)
According to the website, RPM Fusion provides software that the Fedora Project or Red Hat doesn't want to ship. 
To set it up, just walk through the [Configuration page](https://rpmfusion.org/Configuration)
I think the most important part is to get multimedia complement packages from RPM fusion.
 

#### Flatpak

Flatpak provides a quick setup command for Fedora here: [Fedora Quick Setup](https://flatpak.org/setup/Fedora).
 

### 3. Configure time setting for dual booting

Since I am dual booting Windows with Fedora, I have to make sure Fedora treats system time the same as Windows. Otherwise every time I switch system I will have to sync the time again manually. 
I already set my Windows to use UTC as BIOS clock.
The following command set Linux to use UTC time. (It might be the default I think)

```bash
$ timedatectl set-local-rtc 0 --adjust-system-clock
```

Run `timedatectl` to verify it:

```
 Local time: 六 2022-09-10 22:20:02 CST
 Universal time: 六 2022-09-10 14:20:02 UTC
 RTC time: 六 2022-09-10 14:20:02
 Time zone: Asia/Taipei (CST, +0800)
System clock synchronized: yes
 NTP service: active
 RTC in local TZ: no
```

### 4. Setup NVIDIA Driver

I use NVIDIA graphic cards. With secure boot enabled it's a bit complicated to set it up. 
I get a module missing error message when login to Fedora at the beginning. 
 
To solve it there ara a guide about secure boot from RPM Fusion: [Howto/Secure Boot](https://rpmfusion.org/Howto/Secure%20Boot) 
I found a clear walk through guide on [https://blog.monosoul.dev/](https://blog.monosoul.dev/): [Automatically sign NVidia Kernel module in Fedora 36](https://blog.monosoul.dev/2022/05/17/automatically-sign-nvidia-kernel-module-in-fedora-36/) 
It solved the problem perfectly for me.
 

### 5. Use X11 instead of Wayland

By default GNOME use Wayland, I just can't get dual display with hybrid graphics work on it.
So I set it back to X11, hope the problem can be solve someday... 
 
Edit `/etc/gdm/custom.conf` and set `WaylandEnable=false` then reboot. 
It should be using X11.
 

### 6. Customizing GNOME

GNOME in Fedora 36 is already great in my opinion. Just for more settings, install GNOME tweak. 
 
Also, install GNOME extensions. I am using three extensions.

- [Dash to Dock](https://micheleg.github.io/dash-to-dock/index.html)
- [AppIndicator and KStatusNotifierItem Support](https://github.com/ubuntu/gnome-shell-extension-appindicator)
- [Sound Input & Output Device Chooser](https://github.com/kgshank/gse-sound-output-device-chooser)

 

### 7. Customizing Terminal

Actually I never customize the terminal before. Previously I use Ubuntu and Pop!\_OS, I think the terminal looks decent and I don't really care about it.
But the default terminal on Fedora looks a bit too simple, I would like at least some more color highlighting. 
Install the Fancy bash prompt from [synth-shell](https://github.com/andresgongora/synth-shell). It has a easy automatic setup.
 

### 8. Install Piper

[Piper](https://github.com/libratbag/piper)

```bash
$ dnf install piper
```

To configure my gaming mice, use Piper for more dpi and buttons settings. 
 

## Get ready for daily use

This part is not specific for Linux. It's about setting up some software for my daily usage.

### Firefox setup

I use Firefox as my web browser. Sign in my account and it will sync all the extensions and bookmarks automatically. 
Then navigate to `about:config`, there are three flags I will set to true.

```
layers.acceleration.force-enabled // for hardware acceleration
gfx.webrender.all // for faster page rendering
media.setsinkid.enabled // to change audio devices
```

### Visual Studio Code

VS Code is my primary code editor. 
Install it using the official repo: [Visual Studio Code on Linux](https://code.visualstudio.com/docs/setup/linux)

Login to my github account, it will sync all settings and extensions for me.

## Conclusion

This is my basic setup for Fedora 36.
Fedora 37 is coming soon, hope it will become even better.

My list of things to do after installing a new Linux distro

**★ This post was originally published on my Medium: [First try of using Typescript with React. My thoughts](https://medium.com/鳥-crl/first-try-of-using-typescript-with-react-my-thoughts-5667c97d8e80) ★**
 

Recently, I tried many things that I haven’t used on web development. 
For example, usually I use **webpack** to build my development environment, or sometimes just create-react-app. In the last project I tried **parcel** and I love it.

 

**Typescript** is a thing that I think I must learn and I think I would love it for a long time. In this article I will show some thoughts on using typescript with react. 
This article is not about teaching or showing techniques of typescript & react. Just about some personal thoughts.
 

> 38% of bugs could have been prevented by TypeScript

 
<iframe width="560" height="315" src="https://www.youtube.com/embed/P-J9Eg7hJwE" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 

This is a talk in JSConf 2019. Airbnb’s developer says Typescript can help preventing 38% of bugs. Although some people didn’t agree of the number, it still means a lot of bugs in Javascript are caused by types.

## Dynamic vs. Static

Javascript is dynamically typed, we gain some benefit by dynamic type, coercions, especially the efficiency to rapidly make a working project. 
But as the project grows, the time pass through, the team grows. It usually leads to many weird bugs. These bugs are pretty hard to trace. Even though we make a lot of guidelines in coding, the bugs just kept popping out.
 
In Taiwan, most of the computer science department in university teaches static language for the first language, like C++ & JAVA. My first language is JAVA, when I start coding with JAVA, the type, the ide error message annoys me pretty much. So when I learned Javascript, Ruby, Python. I love the dynamic type system. It feels like I can control everything. No more error messages. 
Then I woke up from the dream. Because of my bad habits of coding, the dynamic type leads to tons of bugs. 
I referenced many Javascript guidelines of big company such as google, airbnb, make constraints of coding to minimize bugs.
 

**So why not bring the static type into Javascript ?**

## Moving to Typescript

Shifting to Typescript is pretty easy. By renaming .js file to .ts we can gain some benefit by **type inference** without changing code. 
Learning to use typescript is all about design patterns. The syntax of **type annotation** is simple. 
After using Typescript to build a project. The biggest benefit I gain is about **functions**. In Javascript, passing variables in and out often mess up the types. 
In Typescript we can clearly notice the types go in the function and the types goes out. Also we can get autocomplete, error messages immediately inside the code editor.

![function](function.jpg)

That’s a huge enhancement of coding experience.

## Typescript with React

As a react developer, using Typescript is a great and it’s not a big pain to switch to Typescript. 
Previously we use **PropTypes** to provide type checks in react components. 
By using Typescript, we use interfaces to define the types of states and props. In my opinion, it’s even less code than before.

![Props / state type annotation with hooks](proptypes.jpg)

Of course there’s more design patterns have to learn such as integrating redux. I’m still learning now either.

## Conclusion

Many people get confused about Javascript types, I am one of them. I knows how to use these stuff, these features in the language, but never care about the types passing through functions and functions. 
Even though I’ve learned a static language, I messed up. 
By learning and using Typescript, I knows the language itself better. 
By searching and learning with the type I should annotate, I gain more than the Typescript main feature like type checks.
 

I think I would use Typescript instead of vanilla Javascript in my new projects.

Blog