Qiuxiaori

[dependencies]
rand = "0.3"
hammer = { version = "0.5.0"} // 基於 Rust 官方倉庫 crates.io，通過版本說明來描述
color = { git = "https://github.com/bjz/color-rs" } // 基於項目源代碼的 git 倉庫地址，通過 URL 來描述
geometry = { path = "crates/geometry" } // 基於本地項目的絕對路徑或者相對路徑，通過類 Unix 模式的路徑來描述

[http]
check-revoke = false
# proxy = "http://x.x.x.x:8888" // 於虛擬機內未聯網開發時 作代理使用

[source.crates-io]
replace-with = 'rsproxy'
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"

[net]
git-fetch-with-cli = true

enum Option<T> {
		Some(T),
		None,
}

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("p.x = {}", p.x());
}

pub fn notify(item: &(impl Summary + Display)) {} // 語法糖形式
pub fn notify<T: Summary + Display>(item: &T) {} // 特徵約束的形式

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}

fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{}

let mut v1 = Vec::with_capacity(10);
v1.extend([1, 2, 3]);    // 附加數據到 v
println!("Vector 長度是: {}, 容量是: {}", v.len(), v.capacity());

let mut v =  vec![1, 2];
assert!(!v.is_empty());         // 檢查 v 是否為空

v.reserve(100);                 // 調整 v 的容量，至少要有 100 的容量

v.insert(2, 3);                 // 在指定索引插入數據，索引值不能大於 v 的長度， v: [1, 2, 3] 
assert_eq!(v.remove(1), 2);     // 移除指定位置的元素並返回, v: [1, 3]
assert_eq!(v.pop(), Some(3));   // 刪除並返回 v 尾部的元素，v: [1]
assert_eq!(v.pop(), Some(1));   // v: []
assert_eq!(v.pop(), None);      // 記得 pop 方法返回的是 Option 枚舉值
v.clear();                      // 清空 v, v: []

let mut v1 = [11, 22].to_vec(); // append 操作會導致 v1 清空數據，增加可變聲明
v.append(&mut v1);              // 將 v1 中的所有元素附加到 v 中, v1: []
v.truncate(1);                  // 截斷到指定長度，多餘的元素被刪除, v: [11]
v.retain(|x| *x > 10);          // 保留滿足條件的元素，即刪除不滿足條件的元素

let mut v = vec![11, 22, 33, 44, 55];
// 刪除指定範圍的元素，同時獲取被刪除元素的迭代器, v: [11, 55], m: [22, 33, 44]
let mut m: Vec<_> = v.drain(1..=3).collect();    

let v2 = m.split_off(1);        // 指定索引處切分成兩個 vec, m: [22], v2: [33, 44]

let v2 = vec![11, 22, 33, 44, 55]; // 通過切片截取數組
let slice = &v2[1..=3];
assert_eq!(slice, &[22, 33, 44]);

fn main() {
    let mut vec = vec![1.0, 5.6, 10.3, 2.0, 15f32];    
    vec.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
    assert_eq!(vec, vec![1.0, 2.0, 5.6, 10.3, 15f32]);
}

// 自定義一個按照年齡倒序排序的對比函數
people.sort_unstable_by(|a, b| b.age.cmp(&a.age));

#[derive(Debug, Ord, Eq, PartialEq, PartialOrd)] // derive 屬性
struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }
}

fn main() {
    let mut people = vec![
        Person::new("Zoe".to_string(), 25),
        Person::new("Al".to_string(), 60),
        Person::new("Al".to_string(), 30),
        Person::new("John".to_string(), 1),
        Person::new("John".to_string(), 25),
    ];

    people.sort_unstable();

    println!("{:?}", people);
}
// => [Person { name: "Al", age: 30 }, Person { name: "Al", age: 60 }, Person { name: "John", age: 1 }, Person { name: "John", age: 25 }, Person { name: "Zoe", age: 25 }]

fn main() {
	use std::collections::HashMap;
	
	let teams_list = vec![
	    ("中國隊".to_string(), 100),
	    ("美國隊".to_string(), 10),
	    ("日本隊".to_string(), 50),
	];
	
	let teams_map: HashMap<_,_> = teams_list.into_iter().collect();
	println!("{:?}",teams_map)
}

{
    let r;
    {
        let x = 5;
        r = &x;
    }
    println!("r: {}", r);
}

&i32        // 一個引用
&'a i32     // 具有顯式生命週期的引用
&'a mut i32 // 具有顯式生命週期的可變引用

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

let s: &'static str = "我沒啥優點，就是活得久，嘿嘿";

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>( // 聲明生命週期和範型
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann); // 因為要用格式化 {} 來輸出 ann，因此需要它實現 Display 特徵。
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
   let closure_slision = fun(|x: &i32| -> &i32 { x });
   assert_eq!(*closure_slision(&45), 45);
   // Passed !
}

fn fun<T, F: Fn(&T) -> &T>(f: F) -> F {
   f
}

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

    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新編譯器中，r1,r2作用域在這裡結束

    let r3 = &mut s;
    println!("{}", r3);
}

[profile.release]
panic = 'abort'

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}

// 行註釋

/**
	塊註釋
*/

/// `add_one` 將指定值加1
///
/// # Examples
///
/// ```
/// let arg = 5;
/// let answer = my_crate::add_one(arg);
///
/// assert_eq!(6, answer);
/// ```
pub fn add_one(x: i32) -> i32 {
    x + 1
}

/** `add_two` 將指定值加2

*/
pub fn add_one(x: i32) -> i32 {
    x + 1
}

cargo doc 

cargo doc --open

/// ```
/// # // 使用#開頭的行會在文檔中被隱藏起來，但是依然會在文檔測試中運行
/// # fn try_main() -> Result<(), String> {
/// let res = world_hello::compute::try_div(10, 0)?;
/// # Ok(()) // returning from try_main
/// # }
/// # fn main() {
/// #    try_main().unwrap();
/// #
/// # }
/// ```
pub fn try_div(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Divide-by-zero"))
    } else {
        Ok(a / b)
    }
}

let i = 3.1415926;
let s = String::from("hello");
let v = vec![1, 2, 3];
let p = Person {
    name: "sunface".to_string(),
    age: 18,
};
println!("{}, {}, {}, {}", i, s, v, p);

// {:?}
[1, 2, 3], Person { name: "sunface", age: 18 }

// {:#?}
[
    1,
    2,
    3,
], Person {
    name: "sunface",
}

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

use std::fmt;
impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "大佬在上，請受我一拜，小弟姓名{}，年芳{}，家裡無田又無車，生活苦哈哈",
            self.name, self.age
        )
    }
}
fn main() {
    let p = Person {
        name: "sunface".to_string(),
        age: 18,
    };
    println!("{}", p);
}