let a: [i32; 5] = [1, 2, 3, 4, 5];
let a = [3; 5] = [3, 3, 3, 3, 3];

let number = if condition {
1
} else {
2
};

loop {
do someting;
}
 
fn main() {
    let mut counter = 0;
    let result = loop {
        counter +=1;
        if counter %10 == 0 {
            break counter * 10;
        }
    };
    log(result);
}
 
while condition {
dosomething;
}
 
for element in a.iter() {}
 
// 1-32
for num in (1..33).rev() {
	println!("{}", num);
}
// 1-33
1..=33

let s1 = String::from("test string");
let s2 = s1; //浅拷贝，移动
// 这里s1将被废弃，无法再使用
let s2 = s1.clone(); //深拷贝，s1仍能使用

fn change(some_string: &mut String) {
    some_string.push_str(", world!");
}
 
fn main() {
    let mut s = String::from("hello");
    change(&mut s);
}

struct User {
    email: String,
    username: String,
    active: bool,
    sign_in_count: u64,
}
 
fn build_user(name: String, email: String) -> User {
    User {
	    // email: email,
        email,
        name,
        active: true,
        sign_in_count: 1,
    }
}
 
fn main() {
    let email = String::from("email");
    let name = String::from("name");
    let user1 = build_user(name, email);
	let user2 = User {
		email: String::from("email2"),
        name: String::from("user2"),
        // 其余值与user1相同
        ..user1
    };
}

struct Color(i32, i32, i32);

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
 
fn main() {
    let rect1 = Rectangle {
        width: 10,
        height: 3,
    };
    println!("area is {:#?}", rect1);
}

struct Rect {
width: u32,
height: u32
}
 
impl Rect {
	fn area(&self) -> u32 {
		self.width*self.height
	 }
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}
 
fn main() {
    let square1 = Rectangle::square(4);
    println!("{:?}", square1);
}

enum IpAddrKind {
    V4(u8, u8, u8, u8),
    V6(String),
    Move {x: i32, y: i32 },
}
 
let home = IpAddrKind::V4(127, 0, 0, 1);
 
// 枚举方法
impl IpAddrKind {
	fn call(&self) {
 
	}
}

// 标准库定义为
enum Option<T> {
	Some(T),
	None,
}
let a_num = Some(3);
let absent_num: Option<i32> = None;

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,
	}
}
 
let some_u8_value = 0u8;
match some_u8_value {
	1 => println!("one"),
	3 => println!("three"),
	_ => println!("Nothing"),
	// 表示什么也不发生
	// _ => (),
};
 
// if let
let value = Some(3);
//     模式      表达式
if let Some(3) = value {
	println!("three");
}
 
// if let else
let mut count = 0;
match coin {
	Coin::Quarter(state) => println!("something"),
	_ => count +=1,
}
 
if let Coin::Quarter(state) = coin {
	println!("something");
} else {
	count+=1;
}
 

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
 
        fn seat_at_table() {}
    }
 
    mod serving {
        fn take_order() {}
 
        fn serve_order() {}
 
        fn take_payment() {}
    }
}
 
pub fn eat_at_restaurant() {
	// 绝对路径
    crate::front_of_house::hosting::add_to_waitlist();
    // 相对路径
    front_of_house::hosting::add_to_waitlist();
}

fn serve_order() {}
 
mod back_of_house {
	fn fix_incorrect_order() {
		cook_order();
		// super跳转到back_of_house的父模块
		super::serve_order();
	}
 
	fn cook_order() {}
}

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_frult: String,
    }
 
    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_frult: String::from("peaches"),
            }
        }
    }
}
 
pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("Rye");
 
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);
 
	// 无法通过编译，因为seasonal_frult为私有变量
    // meal.seasonal_frult = String::from("blueberies");
}

pub enum Appetizer {
	Soup,
	Salad,
}
// 公开枚举会同时将所有字段公开

// as
use std::fmt::Result;
use std::io::Result as IoResult;
 
use std::{cmp::Ordering, io};
 
use std::io;
use std::io::Write;
// ==
use std::io::{self, Write};
 
use std::colllections::*;
 
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}
 
use front_of_house::hosting;
 
pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

pub use crate::front_of_house::hosting;

// src/lib.rs
mod front_of_house;
 
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
hosting::add_to_waitlist();
hosting::add_to_waitlist();
}
 
// src/front_of_house.rs
pub mod hosting {
	pub fn add_to_waitlist() {}
}

use rand::Rng;
fn main() {
	let secret_number = rand::thread_rng().gen_range(1, 101);
}

let v: Vec<i32> = Vec::new();
let mut v = vec![1, 2, 3];
v.push(3);
let third: &i32 = &v[2];
 
match v.get(2) {
	Some(3) => println!("3"),
	None => println!("None"),
}

enum SpreadsheetCell {
	Int(i32),
	Float(f64),
	Text(String),
}
 
let row = vec![
	SpreadsheetCell::Int(3),
	SpreadsheetCell::Text(String::from("blue")),
	SpreadsheetCell::Float(10.12),
];

let mut s = String::from("hello");
s.push_str(", world"); // 添加字符
 
// 切片
let s = String::from("hello world");
let hello = &s[0..5];
let len = s.len();
let world = &s[6..len];
let world = &s[6..];
 
let s1 = String::from("切记");
let test = &s1[0..3]; // 前三字节数据
println!("{}", test); // 切

let mut s = String::from("foo");
s.push_str("bar");
s.push('l'); // 拼接单个字符
let s1 = String::from("Hello,");
let s2 = String::from("world!");
let s3 = s1 + &s2; // s1被移动
 
// 格式化
let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
 
let s = format!("{}-{}-{}", s1, s2, s3);

// 遍历
let s = String::from("Здравствуйте");
for i in s.chars() { // 遍历每个字符
    println!("{}", i);
}
for i in s.bytes() { // 遍历每一原始字节数据
    println!("{}", i);
}

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);
 
let teams = vec![String::from("Blue"), String::from("Yellow")];
let init_scores = vec![10, 50];
 
let scores: HashMap<_, _> = teams.iter().zip(init_scores.iter()).collect();

let score = scores.get(&String::from("Blue"));
match score {
	Some(i) => println!("{}", i),
	None => (),
}
 
for (k, v) in &scores {
	println!("{}: {}", k, v);
}

// 覆盖旧值
let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Blue"), 25);
println!("{:?}", scores);
 
// 键不存在时插入
scores.entry(String::from("Blue")).or_insert(50);
 
// 基于旧值更新值
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);

[profile.release]
panic = 'abort'

use std::{fs::File, io::ErrorKind};
 
fn main() {
    let _f = File::open("hello.txt");
 
    let _f = match _f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("create file error"),
            },
            other_errors => panic!("{:?}", other_errors),
        },
    };
}
 
fn main() {
    let f = File::open("hello.txt").map_err(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("create failed: {:?}", error);
            })
        } else {
            panic!("uknown error");
        }
    });
}
 
// ok时取出值，err时调用panic
let f = File::open("hello.txt").unwrap();
// 同上，但可指定panic的提示信息
let f = File::open("hello.txt").expect("custom");

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");
 
    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };
    let mut s = String::new();
    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}
 
// 简化
fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}
fn read_username_from_file() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("hello.txt")?.read_to_string(&mut s)?;
    Ok(s)
}
 
fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}

use std::error::Error;
// Box<dyn Error>: 任何可能的错误
fn main() -> Result<(), Box<dyn Error>> {
    Ok(())
}

struct Guess {
    value: i32,
}
impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {}", value);
        }
        Guess { value }
    }
 
    pub fn value(&self) -> i32 {
        self.value
    }
}

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}
 
struct Point<T> {
	y: T,
	x: T,
}
struct Point<T, U> {
	x: T,
	y: U,
}
 
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}
 
# 单独为f32类型添加方法
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}
 
pub trait Summary {
    fn summarize(&self) -> String;
}
 
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}
 
impl Summary for NewsArticle {}

pub fn notify(item: impl Summary + Display) {
    println!("Breaking news! {}", item.summarize());
}
pub fn notify<T: Summary + Display>(item: T) {
    println!("Breaking news! {}", item.summarize());
}
 
fn returns_summarizable() -> impl Summary {}

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

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

struct ImportantExcerpt<'a> {
    part: &'a str,
}
 
impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

let s: &'static str = "I have a static lifetime.";

fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

#[test]
#[should_panic]
// or
#[should_panic(expected = "something should be contained in fn panic info")]
fn will_panic() {
	// something
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }
}

# adder/tests/integration_test.rs
use adder;
 
#[test]
fn it_adds_two() {
    assert_eq!(4, adder::add_two(2));
}

use std::thread;
use std::time::Duration;
 
fn main() {
    let simulated_random_number = 7;
 
    let expensive_closure = |num| {
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    };
    let result = expensive_closure(simulated_random_number);
    println!("{}", result)
}

fn main() {
    let simulated_random_number = 7;
    let mut expensive_result = Cacher::new(|num| {
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    });
    let result = expensive_result.value(simulated_random_number);
    println!("{result}");
}
 
struct Cacher<T>
where
    T: Fn(u32) -> u32,
{
    calculation: T,
    value: Option<u32>,
}
 
impl<T> Cacher<T>
where
    T: Fn(u32) -> u32,
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }
    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}

let x = 4;
let equal_to_x = |z| z == x;
let y = 4;
assert!(equal_to_x(y));

fn main() {
    let x = vec![1, 2, 3];
    let equal_to_x = move |z| z == x;
    println!("can't use x here: {:?}", x);
    let y = vec![1, 2, 3];
    assert!(equal_to_x(y));
}

let v = vec![1, 2, 3, 4];
let mut mv = vec![1, 2, 3, 4];
for i in &v { // same as v.iter()
	println!("{}", i);
}
for i in &mut mv { // same as v.iter_mut()
	*i += 50;
}
for i in &mut mv {
	println!("{}", i);
}
 
// 相当于 v.into_iter() 会发生值移动
for i in v {
 
}

let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
 
// into_iter 取得所有权，filter 取得引用
v2.into_iter().filter(|x| *x > 2).for_each(|f| {
	println!("{}", f);
});

struct Counter {
    count: u32,
}
 
impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}
 
impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}
 
    let sum: u32 = Counter::new()
        .zip(Counter::new().skip(1))
        .map(|(a, b)| a * b)
        .filter(|x| x % 3 == 0)
        .sum();

# cargo.toml
[profile.dev]
opt-level = 0
 
[profile.release]
opt-level = 3
 
[package]
name = "guessing_game"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2018"
description = "A fun game where you guess what number the computer has chosen."
license = "MIT OR Apache-2.0"
 
[dependencies]

# Examples
# Panics 指出函数可能引发panic的场景
# Errors 可能发生的错误
# Safety 函数不安全的原因

[workspace]
 
members = [
  "adder",
]

# adder/Cargo.toml
[dependencies]
add-one = { path = "../add-one" }

let b = Box::new(4);
println!("{b}");

enum List {
    Cons(i32, Box<List>),
    Nil,
}
 
use crate::List::{Cons, Nil};
 
fn main() {
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil))))));
}

use std::ops::Deref;
 
struct MyBox<T>(T);
impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}
 
impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}
 
fn main() {
    let x = 5;
    let y = MyBox::new(5);
    assert_eq!(5, *y);
}

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.");
}

let c = CustomSmartPointer {
	data: String::from("my stuff"),
};
drop(c);

enum List {
    Cons(i32, Rc<List>),
    Nil,
}
 
use crate::List::{Cons, Nil};
use std::rc::Rc;
 
fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}

use std::cell::RefCell;
 
struct Person {
    age: RefCell<u32>,
}
impl Person {
    pub fn new() -> Person {
        Person { age: 12.into() }
    }
    pub fn set_age(&self, age: u32) {
        *self.age.borrow_mut() = age;
    }
}
 
fn main() {
    let person = Person::new();
    person.set_age(10);
    println!("{}", person.age.borrow());
    let mut borrow2 = person.age.borrow_mut();
    *borrow2 = 2;
}

use std::cell::RefCell;
use std::rc::Rc;
 
#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}
 
impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None,
        }
    }
}
 
use List::{Cons, Nil};
fn main() {
    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
 
    println!("a initial rc count = {}", Rc::strong_count(&a));
    println!("a next item = {:?}", a.tail());
 
    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
 
    println!("a rc count after b creation = {}", Rc::strong_count(&a));
    println!("b initial rc count = {}", Rc::strong_count(&b));
    println!("b next item = {:?}", b.tail());
 
    if let Some(link) = a.tail() {
        *link.borrow_mut() = Rc::clone(&b);
    }
 
    println!("b rc count after changing a = {}", Rc::strong_count(&b));
    println!("a rc count after changing a = {}", Rc::strong_count(&a));
 
    println!("a next item = {:?}", a.tail());
}

use std::cell::RefCell;
use std::rc::{Rc, Weak};
 
#[derive(Debug)]
struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
    parent: RefCell<Weak<Node>>,
}
 
fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        children: RefCell::new(vec![]),
        parent: RefCell::new(Weak::new()),
    });
    println!("leaf parent: {:?}", leaf.parent.borrow().upgrade());
    let branch = Rc::new(Node {
        value: 5,
        children: RefCell::new(vec![Rc::clone(&leaf)]),
        parent: RefCell::new(Weak::new()),
    });
    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
    println!("leaf parent: {:?}", leaf.parent.borrow().upgrade());
}

use std::thread;
use std::time::Duration;
 
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("spawn: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    for i in 1..5 {
        println!("main: {}", i);
        thread::sleep(Duration::from_millis(1));
    }
    handle.join().unwrap();
}

use std::thread;
 
fn main() {
    let v = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("{:?}", v);
    });
    handle.join().unwrap();
}

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);
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;
 
fn main() {
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];
        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });
    for received in rx {
        println!("Got: {}", received);
    }
}

use std::sync::Mutex;
fn main() {
    let m = Mutex::new(3);
    {
        let mut num = m.lock().unwrap();
        *num = 6;
    }
    // = drop(num);
    println!("m={:?}", m);
}

use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
 
fn main() {
    let count = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 1..=10 {
        let count = Arc::clone(&count);
        let handle = thread::spawn(move || {
            let mut num = count.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("count: {}", *count.lock().unwrap());
}

pub trait Draw {
    fn draw(&self);
}
 
pub struct Screen {
    pub components: Vec<Box<dyn Draw>>,
}
 
impl Screen {
    pub fn run(&self) {
        for components in self.components.iter() {
            components.draw();
        }
    }
}
 
pub struct Screen<T: Draw> {
    pub components: Vec<T>,
}
 
impl<T> Screen<T>
    where T: Draw {
        pub fn run(&self) {
            for components in self.components.iter() {
                components.draw();
            }
        }
    }

fn main() {
    let screen = Screen {
        components: vec![
            Box::new(SelectBox {
                width: 75,
                height: 10,
                options: vec![String::from("yes"), String::from("No")],
            }),
            Box::new(Button {
                width: 50,
                height: 10,
                label: String::from("OK"),
            }),
        ],
    };
    screen.run();
}

pub struct Post {
    state: Option<Box<dyn State>>,
    content: String,
}
 
impl Post {
    pub fn new() -> Post {
        Post {
            state: Some(Box::new(Draft {})),
            content: String::new(),
        }
    }
    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }
    pub fn content(&self) -> &str {
        self.state.as_ref().unwrap().content(self)
    }
    pub fn request_review(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.request_review())
        }
    }
    pub fn approve(&mut self) {
        if let Some(s) = self.state.take() {
            self.state = Some(s.approve())
        }
    }
}
 
trait State {
    fn request_review(self: Box<Self>) -> Box<dyn State>;
    fn approve(self: Box<Self>) -> Box<dyn State>;
    fn content<'a>(&self, post: &'a Post) -> &'a str {
        ""
    }
}
 
struct Draft {}
 
impl State for Draft {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        Box::new(PendingReview {})
    }
    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
}
 
struct PendingReview {}
 
impl State for PendingReview {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }
    fn approve(self: Box<Self>) -> Box<dyn State> {
        Box::new(Published {})
    }
}
 
struct Published {}
 
impl State for Published {
    fn request_review(self: Box<Self>) -> Box<dyn State> {
        self
    }
    fn approve(self: Box<Self>) -> Box<dyn State> {
        self
    }
    fn content<'a>(&self, post: &'a Post) -> &'a str {
        &post.content
    }
}
 
use blog::Post;
 
fn main() {
    let mut post = Post::new();
 
    post.add_text("I ate a salad for lunch today");
    assert_eq!("", post.content());
 
    post.request_review();
    assert_eq!("", post.content());
 
    post.approve();
    assert_eq!("I ate a salad for lunch today", post.content());
}

pub struct Post {
    content: String,
}
 
pub struct DraftPost {
    content: String,
}
 
impl Post {
    pub fn new() -> DraftPost {
        DraftPost {
            content: String::new(),
        }
    }
 
    pub fn content(&self) -> &str {
        &self.content
    }
}
 
impl DraftPost {
    pub fn add_text(&mut self, text: &str) {
        self.content.push_str(text);
    }
    pub fn request_review(self) -> PendingReviewPost {
        PendingReviewPost {
            content: self.content,
        }
    }
}
 
pub struct PendingReviewPost {
    content: String,
}
 
impl PendingReviewPost {
    pub fn approve(self) -> Post {
        Post {
            content: self.content,
        }
    }
}
 
use blog::Post;
 
fn main() {
    let mut post = Post::new();
    post.add_text("I ate a salad for lunch today");
    let post = post.request_review();
    let post = post.approve();
    assert_eq!("I ate a salad for lunch today", post.content());
}

match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
}

fn main() {
    let favorite_color: Option<&str> = None;
    let is_tuesday = false;
    let age: Result<u8, _> = "34".parse();
 
    if let Some(color) = favorite_color {
        println!("Using your favorite color, {}, as the background", color);
    } else if is_tuesday {
        println!("Tuesday is green day!");
    } else if let Ok(age) = age {
        if age > 30 {
            println!("Using purple as the background color");
        } else {
            println!("Using orange as the background color");
        }
    } else {
        println!("Using blue as the background color");
    }
}

let mut stack = Vec::new()
stack.push(1);
stack.push(2);
 
while let Some(top) = stack.pop() {
	println("{}", top);
}

let v = vec!['a', 'b', 'c'];
 
for (index, value) in v.iter().enumerate() {
    println!("{} is at index {}", value, index);
}

let (x, y, z) = (1, 2, 3);

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("Current location: ({}, {})", x, y);
}
 
fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

let x = 1;
 
match x {
	// or
    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!("early ASCII letter"),
    'k'..='z' => println!("late ASCII letter"),
    _ => println!("something else"),
}

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);
}
 
// 简写
let Point { x, y } = p;

fn main() {
    let p = Point { x: 0, y: 7 };
 
    match p {
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        Point { x: 0, y } => println!("On the y axis at {}", y),
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }
}

enum Color {
   Rgb(i32, i32, i32),
   Hsv(i32, i32, i32),
}
 
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}
 
fn main() {
    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
 
    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => {
            println!(
                "Change the color to red {}, green {}, and blue {}",
                r,
                g,
                b
            )
        }
        Message::ChangeColor(Color::Hsv(h, s, v)) => {
            println!(
                "Change the color to hue {}, saturation {}, and value {}",
                h,
                s,
                v
            )
        }
        _ => ()
    }
}

let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });

struct Point {
    x: i32,
    y: i32,
    z: i32,
}
 
let origin = Point { x: 0, y: 0, z: 0 };
 
match origin {
    Point { x, .. } => println!("x is {}", x),
}

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

let x = 4;
let y = false;
 
match x {
	// (4 | 5 | 6) if y
    4 | 5 | 6 if y => println!("yes"),
    _ => println!("no"),
}

enum Message {
    Hello { id: i32 },
}
 
let msg = Message::Hello { id: 5 };
 
match msg {
    Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable)
    },
    Message::Hello { id: 10..=12 } => {
        println!("Found an id in another range")
    },
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}

let mut num = 5;
 
let r1 = &num as *const i32;
let r2 = &mut num as *mut i32;
 
let address = 0x12345usize;
let r = address as *const i32;

unsafe {
	println!("r1 is: {}", *r1);
}

unsafe fn dangerous() {}
 
fn main() {
    unsafe {
        dangerous();
    }
}

fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = slice.len();
    let ptr = slice.as_mut_ptr();
 
    assert!(mid <= len);
 
    unsafe {
        (
            slice::from_raw_parts_mut(ptr, mid),
            slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}