fn main() {
  let y = {
    let x = 3;
    x + 1 // 这里如果加 ;那么就是语句了
  }
  println!(y); // 4
}

fn sum_num(x: i32, y: i32) {
  let x = x + 1; // 语句
  let y = y + 5; // 语句
  x + y // 表达式
}

fn add_sum(i: i32, j: i32) -> i32 {
  i + j
}

use std::fmt::Debug;

fn report<T: Debug>(item: T) {
  println!("{:?}", T);
}

fn clear(text: &mut String) -> () {
  *text = String::from("")
}

fn exit_end() -> ! {
  panic("end of road!");
}

fn forever() -> ! {
  loop {
    // ...
  };
}

{
  let s = "hello"; // s 声明后开始有效
} // 作用域结束，s 不再有效

let x = 5;
let y = x;
println!(x);

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

fn main() {
  let x = "hello world";
  let y = x;
  println!("{}, {}", x, y);
}

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

let x = 5;
let y = x;

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

fn main() {
  let s = String::from("hello");
  
  takes_ownship(s); // s 的值移动到函数里
  // s 不再有效
  
  let x = 5;
  
  makes_copy(x); // x 移动到这个函数里
  // i32 是可 Copy 的，所以 x 继续有效
}

fn take_ownship(str: String) {
  println!("{}", str);
} // str 移除作用域，drop 掉其占用的内存

fn makes_copy(interger: i32) {
  println!("{}", interger);
} // interger 移除作用域

fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 移给 s1

    let s2 = String::from("hello");     // s2 进入作用域

    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中,
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
                                             // 调用它的函数

    let some_string = String::from("hello"); // some_string 进入作用域.

    some_string                              // 返回 some_string 并移出给调用的函数
}

// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域

    a_string  // 返回 a_string 并移出给调用的函数
}

fn main() {
  let x = 5;
  // y 是 x 的一个引用
  let y = &x;
  
  assert_eq!(5, x);
  // *y 便是解引用
  assett_eq!(5, *y);
}

fn main() {
  let s1 = String::from("hello");
  // 通过 &s1 引用的方式，不转移 s1 的所有权
  let len = cal_len(&s1);
	// s1 还可以继续使用
}

// 引用类型，需要在类型前加 &
fn cal_len(s: &String) -> usize {
  s.len()
}

fn main() {
  let s1 = String::from("hello");
  // 通过 &s1 引用的方式，不转移 s1 的所有权
  let len = change_str(&s1);
	// s1 还可以继续使用
}

// 引用类型，需要在类型前加 &
fn change_str(s: &String) {
  s.push_str("world");
}

fn main() {
  let mut s1 = String::from("hello");
  // 通过 &s1 引用的方式，不转移 s1 的所有权
  let len = change_str(&mut s1);
	// s1 还可以继续使用
}

// 引用类型，需要在类型前加 &
fn change_str(s: &mut String) {
  s.push_str("world");
}

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

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

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

let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题

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

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);
} // 老编译器中，r1、r2、r3作用域在这里结束
  // 新编译器中，r3作用域在这里结束

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

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

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

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

fn main() {
  let tup: (i32, f64, u8) = (500, 6.4, 1);
  let first = tup.0;
  let second = tup.1;
}

fn main() {
  // name 的类型是 &str
  let name = "hello world";
  greet(name);
}

fn greet(s: String) {
  println!("你好, {}", s);
}

let s = String:from("hello, world!");
let str = &s;
let str = &s[..];
let str = s.as_str();

let s1 = String::from("hello");
let h = s1[0];

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

let hello = &s[0..5]; // 可省略为 &s[..5]
let world = &s[6..11]; // 可省略为 &s[6..]

let s = String::from("helo");
let len = s.len();

let full = &s[0..len];
let full = &s[..]

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3]; // [2, 3]

fn main() {
  let mut s = String::from("Hello ");
  s.push_str("rust");
  println!("{}", s); // Hello rust
  s.push('!');
  println!("{}", s); // Hello rust!
}

fn main() {
  let mut s = String::from("Hello rust");
  s.insert(5, ',');
  println!("{}", s); // Hello, rust
}

let s = String::from("hello rust, hello rust");
let new_str = s.replace("rust", "world");
println!("{}", new_str); // hello world, hello world

let s = String::from("hello rust, hello rust");
let new_str = s.replacen("rust", "world", 1);
println!("{}", new_str); // hello world, hello rust

let mut s = String::from("hello rust,");
s.replace_range(6.., "world");
println!("{}", s); // hello world

let mut s = String::from("he");
let ch: Option<char> = s.pop();
match ch {
    Some(str) => println!("{}", str),
    None => println!("没有字符了")
}

let mut s = String::from("你好 世界");
s.remove(0);
println!("{}", s); // 好 世界

let mut s = String::from("hello world");
s.truncate(5);
println!("{}", s); // hello

let mut s = String::from("hello world");
s.clear();
println!("{}", s);

let str_append = String::from("hello ");
let str_rust = String::from("rust");
let result = str_append + &str_rust;
let mut result = result + "!";
result += "!!!!";
println!("{}", result); // hello rust!!!!!

let prefix = "hello";
let suffix = "world";
let full = format!("{} {}", prefix, suffix);
println!("{}", full); // hello world

fn main() {
    // 通过 \ + 字符的十六进制表示，转义输出一个字符
    let byte_escape = "I'm writing \x52\x75\x73\x74!";
    println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape);

    // \u 可以输出一个 unicode 字符
    let unicode_codepoint = "\u{211D}";
    let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";

    println!(
        "Unicode character {} (U+211D) is called {}",
        unicode_codepoint, character_name
    );

    // 换行了也会保持之前的字符串格式
    // 使用\忽略换行符
    let long_string = "String literals
                        can span multiple lines.
                        The linebreak and indentation here ->\
                        <- can be escaped too!";
    println!("{}", long_string);
}

fn main() {
    println!("{}", "hello \\x52\\x75\\x73\\x74");
    let raw_str = r"Escapes don't work here: \x3F \u{211D}";
    println!("{}", raw_str);

    // 如果字符串包含双引号，可以在开头和结尾加 #
    let quotes = r#"And then I said: "There is no escape!""#;
    println!("{}", quotes);

    // 如果还是有歧义，可以继续增加，没有限制
    let longer_delimiter = r###"A string with "# in it. And even "##!"###;
    println!("{}", longer_delimiter);
}

for c in "你好世界".chars() {
  println!("{}", c);
}
// 你
// 好
// 世
// 界

for c in "你好世界".bytes() {
  println!("{}", c);
}

228
189
160
229
165
189
228
184
150
231
149
140

struct User {
  username: String,
  email: String
};

let mut user = User {
  username: String::from("Plumbiu"),
  email: String::from("plumbiuzz@gmail.com"),
  active: bool,
};

let mut user = User {
  username: String::from("Plumbiu"),
  email: String::from("plumbiuzz@gmail.com"),
  active: true,
};
user.email = String::from("xxx@gamil.com");

fn build_user(email: String, username: String) -> User {
  email: email,
  username: username,
}

fn build_user(email: String, username: String) -> User {
  email,
  username,
  active: true,
}

let user2 = {
  email: String::from("xxx@qq.com"),
  ..user1
}

#[derive(Debug)]
 struct File {
   name: String,
   data: Vec<u8>,
 }

 fn main() {
   let f1 = File {
     name: String::from("f1.txt"),
     data: Vec::new(),
   };

   let f1_name = &f1.name;
   let f1_length = &f1.data.len();

   println!("{:?}", f1);
   println!("{} is {} bytes long", f1_name, f1_length);
 }

struct Color(i32, i32, i32);
let black = Color(0, 0, 0);

struct AlwaysEqual;

let subject = AlwaysEqual;

// 我们不关心 AlwaysEqual 的字段数据，只关心它的行为，因此将它声明为单元结构体，然后再为它实现某个特征
impl SomeTrait for AlwaysEqual {

}

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

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
		// 使用 {} 格式化输出
    println!("rect1 is {}", rect1);
}

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`
= help: the trait `std::fmt::Display` is not implemented for `Rectangle`
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

error[E0277]: `Rectangle` doesn't implement `Debug`
= help: the trait `Debug` is not implemented for `Rectangle`
= note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`

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

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

    println!("rect1 is {:?}", rect1);
}

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

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

enum PokerSuit {
  Clubs,
  Spades,
  Diamonds,
  Hearts,
}

let heart = PokerSuit::Hearts;
let diamond = PokerSuit::Diamonds;

#[derive(Debug)]
enum PokerSuit {
  Clubs,
  Spades,
  Diamonds,
  Hearts,
}

fn main() {
    let heart = PokerSuit::Hearts;
    let diamond = PokerSuit::Diamonds;

    print_suit(heart);
    print_suit(diamond);
}

fn print_suit(card: PokerSuit) {
    println!("{:?}",card);
}

enum PokerCard {
  	Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

fn main() {
  let c1 = PokerCard::Spades(5);
  let c2 = PokerCard::Diamonds(13);
}

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

let a = [1, 2, 3, 4, 5 , 6];
let first = a[0]; // 获取 a 数组第一个元素
let second = a[1]; // 获取第二个元素

let a = [3;5]

let a = [3, 3, 3, 3, 3];

a[100];

println!("{}", a[100]);
  |            ^^^^^^ index out of bounds: the length is 6 but the index is 100
  |
  = note: `#[deny(unconditional_panic)]` on by default

error: aborting due to previous error

let arr = [String::from("hello"); 3];
println!("{:#?}", arr);

let arr = [String::from("hello"), String::from("hello"), String::from("hello")];
println!("{:#?}", arr);

let arr: [String; 3] = std::array::from_fn(|_i| String::from("hello"));
println!("{:#?}", arr);

let a: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &a[1..3];
assert_eq!(slice, &[2, 3]);

if condition == true {
  // ...
} else {
  // ...
}

fn main() {
  let condition = true;
  let number = if condition {
    5
  } else {
    6
  };
  println!("{}", number);
}

for i in 1..=5 {
  println!("{}", i);
}

for item in &mut collection {
  // ...
}

let a = [4, 3, 2, 1];
for (i, v) in a.iter().enumerate() {
  println("第{}个元素是{}", i + 1, v);
}

for _ in 0..10 {
  // ...
}

let n = 1;
loop {
  if (n > 5) {
    break;
  }
  n++
}

match target {
  模式1 => 表达式1,
  模式2 = > {
    语句1;
    语句2;
    表达式2
  },
  _ => 表达式3 // 默认，相当于 switch 中的 default
}

let mut str = String::from("hello world");
let pop_str = str.pop();
match pop_str {
  Some(ch) => { println!("{}", ch); },
  None => { println!("数值为空"); }
}

enum Ipddr {
    Ipv4,
    Ipv6,
}

fn main() {
  let address = Ipddr::Ipv6;
  let ip_str = match address {
      Ipddr::Ipv4 => "127.0.0.1",
      _ => "::1",
  };
  println!("{}", ip_str); // ::1
}

enum Direction {
    East,
    West,
    North,
    South
}

fn main() {
  let dire = Direction::East;
  match dire {
    Direction::East => println!("East!"),
    Direction::West => println!("West!"),
    Direction::North => println!("North!"),
  }
}

let x = 1;

match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("anything"),
}

let x = 5;

match x {
    1..=5 => println!("one through five"),
    _ => println!("something else"),
}

let x = 'c';
match x {
    'a'..='j' => println!("a - j"),
    'k'..='z' => println!("j - z"),
    _ => println!("啥都没匹配到")
}

let num = Some(4);

match num {
    Some(x) if x < 5 => println!("less than five: {}", x),
    Some(x) => println!("{}", x),
    None => (),
}

let v = Some(3);
match v {
  Some(3) => println!("three"),
  _ => ()
}

let num = Some(3);
if let Some(num) = num  {
  println!("hello, {:?}", num);
}

let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);

while let Some(top) = stack.pop() {
  println!("{}", top);
}

enum MyEnum {
  Foo,
  Bar
}

fn main() {
  let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo];
}

v.iter().filter(|x| x === MyEnum::Foo)

binary operation `==` cannot be applied to type `&&MyEnum`

v.iter().filter(|x| matches!(x, MyEnum::Foo))

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(age) = age {
       println!("匹配出来的age是{}",age);
   }

   println!("在匹配后，age是{:?}",age);
}

在匹配前，age是Some(30)
匹配出来的age是30
在匹配后，age是Some(30)

fn main() {
   let age = Some(30);
   println!("在匹配前，age是{:?}",age);
   if let Some(x) = age {
       println!("匹配出来的age是{}",x);
   }

   println!("在匹配后，age是{:?}",age);
}

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

fn plus_one(x: Option<i32>) -> Option<i32> {
  match x {
      Some(n) => Some(n + 1),
      None => None
  }
}

fn main() {
  let five = Some(5);
  let six = plus_one(five);
  let none = plus_one(None);
}

struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p = Point { x: 0, y: 7 };

  let Point { x: a, y: b } = p;
  assert_eq!(0, a);
  assert_eq!(7, b);
}

struct Point(i32, i32);

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

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

let arr: [u16; 2] = [114, 514];
let [x, y] = arr;

let arr: [i32; 4] = [1, 2, 3, 4];
let [x, .., y] = arr;
println!("x: {}", x); // 1
println!("y: {}", y); // 4

let arr: [i32; 4] = [1, 2, 3, 4];
let [x, _, y, _] = arr;
println!("x: {}", x); // 1
println!("y: {}", y); // 3

let msg = Message::Hello { id: 5 };
match msg {
  Message::Hello { id: id_val @ 1..=5 } => {
    println!("id 值为 {}", id_val);
  },
  Message::Hello { id: 6..=10 } => {
    // 这个分支下无法使用 id
    println!("id 在第二个分支上");
  },
  Message::Hello { id } => {
    println!("id 值为 {}", id);
  }
}

#[derive(Debug)]
struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p @ Point { x: px, y: py } = Point { x: 10, y: 23 };
  println!("x: {}, y: {}", px, py);
  println!("{:?}", p);

  let point = Point { x: 10, y: 5 };
  if let p @ Point { x: 10, y } = point {
    println!("x is 10, y is {} in {:?}", y, p);
  } else {
    println!("x i not 10");
  }
}

match 1 {
  num @ (1 | 2) => {
    println!("num is 1 or 2, {}", num);
  }
  _ => {}
}

struct Circle {
  x: f64,
  y: f64,
  radius: f64,
}

impl Circle {
  // new 是 Circle 的关联函数，因为它的第一个参数不是 self，且 new 并不是关键字
  // new 通常用于初始化当前结构体的实例
  fn new(x: f64, y: f64, radius: f64) -> Circle {
    Circle { x, y, radius }
  }
	// Circle 的方法，&self 表示借用当前的 Circle 的结构体
  fn area(&self) -> f64 {
    std::f64::consts::PI * (self.radius * self.radius)
  }
}

fn main() {
  let c = Circle::new(1.0, 2.0, 3.5);
  println!("面积为：{}", c.area());
}

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

impl Circle {
    fn new(x: f64, y: f64, radius: f64) -> Circle {
      Circle { x, y, radius }
    }
    fn area(&self) -> f64 {
      std::f64::consts::PI * (self.radius * self.radius)
    }
		// radius 方法与 radius 属性同名
    fn radius(&self) -> f64 {
      f64::sqrt(self.area() / std::f64::consts::PI)
    }
}

fn main() {
  let c = Circle::new(1.0, 2.0, 3.5);
  println!("面积为：{}", c.area());
  println!("半径为：{}", c.radius());
}

impl Circle {
  compare(&self, c: &Circle) -> bool {
    &self.radius > c.radius
  }
}

fn main() {
  let c1 = Circle::new(1.0, 2.0, 5.0);
  let c2 = Circle::new(4.0, 1.0, 6.0);
  println!("{}", c1.compare(&c2));
}

impl Circle {
  fn new(x: f64, y: f64, radius: f64) -> Circle {
    Circle { x, y, radius }
  }
  fn area(&self) -> f64 {
    std::f64::consts::PI * (self.radius * self.radius)
  }
}

impl Circle {
  fn radius(&self) -> f64 {
    f64::sqrt(self.area() / std::f64::consts::PI)
  }
}

#![allow(unused)]
#[derive(Debug)]
enum Message {
    User(String),
    Target,
}

impl Message {
    fn call(&self) {
        println!("打给了, {:?}", self::Message::Target)
    }
}

fn main() {
    let m = Message::User("gxj".to_string());
    m.call();
}

fn add_i8(a:i8, b:i8) -> i8 {
    a + b
}
fn add_i32(a:i32, b:i32) -> i32 {
    a + b
}
fn add_f64(a:f64, b:f64) -> f64 {
    a + b
}

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
  a + b
}

fn largest<T>(list: &[T]) -> T

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}