Rust

sudo pacman -S rust

sudo pacman -S rustup
# 设置rustup清华镜像源(https://mirrors.tuna.tsinghua.edu.cn/help/rustup/)
# 我这里长期启用清华镜像
# for zsh
echo 'export RUSTUP_UPDATE_ROOT=https://mirrors.tuna.tsinghua.edu.cn/rustup/rustup' >> ~/.zshrc
echo 'export RUSTUP_DIST_SERVER=https://mirrors.tuna.tsinghua.edu.cn/rustup' >> ~/.zshrc
# 这里安装的是稳定版,还有beta版和nightly版
rustup toolchain install stable

cargo new new_project

rand = "0.8.5"

// 猜数游戏
use std::io;
use rand::Rng;
use std::cmp::Ordering;
fn main() {
    println!("猜数游戏开始!!");
    let screct_num = rand::thread_rng().gen_range(1..101);
    // println!("the screct num is:{}",screct_num);
    loop {
        println!("猜测一个数:");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("读取行失败!!");
        println!("你猜测的数为:{}",guess);
        // shadow
        // let guess:u32= guess.trim().parse().expect("Please type a number");
        let guess:u32 = match guess.trim().parse(){
            Ok(num) => num,
            Err(_) => {
                println!("You must input a num");
                continue;
            }
        };
        match guess.cmp(&screct_num){
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
       }
    }
}

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

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {} {} {}", tup.0, tup.1, tup.2);
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    let b:[i32;5]=[1, 2, 3, 4, 5];
    let c = [3;5]; // => let c = [5, 5 ,5];
}

fn add_five(value:i32)->i32{
    value+5
}

if number < 5{
    println!("condition was true");
} else {
    println!("condition was false");
}

// else if 
if number < 5{
    println!("1");
} else if  number > 7{
    println!("2");
} else {
    println!("3");
}

let number = if condition {5} else {6}

// loop
loop{

}

// while
while condition {
    
}

// for
let a = [1, 2, 3, 4, 5];
for elem in a.iter(){
    println!("the value is: {}",elem);
}

for num in (1..4){
   	println!("the value is: {}",num);
}

for num in (1..4).rev() {
   	println!("the value is: {}",num);
}

let mut s = String::from("Hello");
s.push_str(",World");

let x = 5;
let y = x;

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

fn main(){
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}",s1);
}
// error[E0382]: borrow of moved value: `s1`

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

// 引用
fn main(){
    let s1 = String::from("hello");
    let len = get_length(&s1);
    println!("the len is {}",len);
}


fn get_length(val: &String)-> usize{
    val.len()
}

fn main(){
    let s = String::from("hello world");
    let worldindex = get_substr(&s);
    let hello = &s[0..5];
    let world = &s[6..11];
}

let s = "Hello, World";

fn first_world(s :&String) -> &str{}

fn  first_world(S: &str) -> &str {}

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

struct User{
   username: String,
   email: String,
   sign_in_count: u64,
   active: bool,
}

let user1 = User{
    email: String::from("violet@126.com"),
    username: String::from("violet"),
    sign_in_count: 12,
    active: true,
}

User.email

let mut user1 = User{
    email: String::from("violet@126.com"),
    username: String::from("violet"),
    sign_in_count: 12,
    active: true,
}
User.email = String::from("overflow@126.com");

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

fn main() {
    // --snip--

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}

fn main() {
    // --snip--

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

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

// #[derive(Debug)]
struct User{
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main(){
    let user1 = User{
        email: String::from("violet@126.com"),
        username: String::from("violet"),
        sign_in_count: 12,
        active: true,
    };
    println!("{:?}",user1);
    println!("{:#?}",user1);
}
// User { username: "violet", email: "violet@126.com", sign_in_count: 12, active: true }
// User {
//     username: "violet",
//     email: "violet@126.com",
//     sign_in_count: 12,
//     active: true,
// }

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

// 定义Rect的方法
impl Rect{
    fn area(&self)->u32{
        self.height * self.width
    }

    fn can_hold(&self, other: &Rect)->bool{
        self.height > other.height && self.width > other.width
    }
}

fn main(){
    let rec = Rect{
        height: 50,
        width: 30,
    };

    let rec2 = Rect{
        height:40,
        width: 20,
    };
    println!("{}",rec.can_hold(&rec2));
    println!("{}",rec.area());
}

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

// 定义Rect的关联函数
impl Rect{
    fn square(size: u32)-> Rect{
        Rect{
            height:size,
            width:size,
        }
    }
}

fn main(){
    // 关联函数调用
    let s = Rect::square(20);
    println!("{:#?}",s);
}

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

fn main(){
    let some_number = Some(5);
    let some_string = Some("A String");
    let absent_num: Option<i32> =None;
}

enum Coin{
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin:Coin)->u8{
    match coin{
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter =>25,
    }
}

fn main(){
    let Penny:u8 = value_in_cents(Coin::Penny);
    println!("{}",Penny);
}

#[derive(Debug)]
enum States{
    Henan,
    Hubei,
}

enum Coin{
    Penny,
    Nickel,
    Dime,
    Quarter(States),
}

fn value_in_cents(coin:Coin)->u8{
    match coin{
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) =>{
            println!{"the state is {:#?}",state};
            5
        },
    }
}

fn main(){
    let Penny:u8 = value_in_cents(Coin::Penny);
    let Henan = Coin::Quarter(States::Henan);
    value_in_cents(Henan);
    println!("{}",Penny);
}

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

}

fn add_one(x:Option<i32>) -> Option<i32>{
    match x{
        None => None,
        Some(i) => Some(i+1);
    }
}

fn main(){
    let v = 0u8;
    match v{
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        // 匹配其余情况，要放在最后
        _ => (),
    }
}

fn main(){
    let v = Some(0u8);
    if let Some(3) = v{
        println!("three");
    }
    // 相当于
        match v{
        Some(3) => println!("three"),
        // 匹配其余情况，要放在最后
        _ => (),
    }
    
}

mod front_of_house {
    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();
}

mod front_of_house {
    pub mod hosting{
        pub fn add_to_waitlist(){}
    }
}
// 绝对
use crate::front_of_house::hosting;
// 相对
use front_of_house::hosting;

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

mod front_of_house {
    pub mod hosting{
        pub fn add_to_waitlist(){}
    }
}
// 绝对
use crate::front_of_house::hosting as Fhosting;
// 相对
use front_of_house::hosting as Fhosting;

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

mod front_of_house {
    pub mod hosting{
        pub fn add_to_waitlist(){}
    }
}
// 外部作用域可以使用hosting::add_to_waitlist()
pub use crate::front_of_house::hosting;

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

use std::{cmp::Ordering,io};

//use std::io
//use std::io::Write
use std::io::{self, Write};

//通配符* ：引入下属路径所有条目
/*应用场景
 *测试： 将所有测试代码引入到tests模块
 *有时被用于预导入（prelude)模块
use std::collections::*;

fn main(){
    let v:Vec<i32> = Vec::new();
    // 初始值创建Vector
    let v1 = vec![1,2,3]; // macro
    // 不用显示声明Vector类型
    let mut v2 = Vec::new();
    v2.push(1);
}

fn main(){
    // 初始值创建Vector
    let mut v1 = vec![1,2,3,4,5]; // macro
    // 不可变引用
    let third: &i32 = &v1[1];
    // 可变引用
    v1.push(6);
    // 不可变引用
    println!("{}",third);
}
// error[E0502]: cannot borrow `v1` as mutable because it is also borrowed as immutable

fn main(){
    // 初始值创建Vector
    let mut v1 = vec![1,2,3,4,5]; // macro
    // 不可变引用
    for i in &mut v1{
        *i += 50;
    }

    for i in v1{
        println!("{}",i);
    }
    
    for (i,elem) in v1.iter().enumerate(){
        println!("{}=={}",i,elem);
    }
}

// Vector与enum搭配
enum SpreadsheetCell{
    Int(i32),
    Float(f64),
    Text(String),
}

fn main(){
    // 模拟存放多种类型
    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Float(10.0),
        SpreadsheetCell::Text(String::from("apple")),
    ];
}

let mut s = String::new();

fn main(){
    let data = "hello world";
    let s1 = data.to_string();
    let s2 = "hello world".to_string();
    let s3 = String::from("hello world");
}

fn main(){
    let mut s = String::from("apple");
    s.push_str(" banana");
    println!("{}",s);
}

fn main(){
    let mut s = String::from("apple");
    s.push_str(" banana");
    s.push('p');
    println!("{}",s);
}

fn main(){
    let s1 = String::from("hello ");
    let s2 = String::from("world");
    let s3 = s1 + &s2;
    // s1被所有权被转移
    // println!("{}",s1);
    println!("{}",s2);
    println!("{}",s3);
}

fn main(){
    let s1 = String::from("hello ");
    let s2 = String::from("world");
    let s3 = String::from("yes");
    let newstr = format!("{}-{}-{}",s1,s2,s3);
    println!("{}",newstr);
}

// String的本质是字符的向量
// 存放Unicode标量值
pub struct String {
    vec: Vec<u8>,
}

fn main(){
    let s = String::from("你好世界");
    // 字节
    for b in s.bytes(){
        println!("{}",b);
    }
    /*  228
	 *  189
	 *  160
	 *  229
	 *  165
	 *  189
	 *  228
	 *  184
	 *  150
	 *  231
	 *  149
	 *  140
	 */
    // 标量
     for b in s.chars(){
        println!("{}",b);
     }
    /* 你
	 * 好
	 * 世
	 * 界
	 */
    // rust标准库没有提供字形簇的获取方法
}

fn main(){
    let s = String::from("你好世界");
    let news = &s[0..2];
    println!("{}",news);
}
// thread 'main' panicked at 'byte index 2 is not a char boundary; it is inside '你' (bytes 0..3) of `你好世界`', src/main.rs:3:17
// note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

use std::collections::HashMap;

fn main(){
    let mut scores: HashMap<String, i32> = HashMap::new();
    scores.insert(String::from("violet"),12);
}

use std::collections::HashMap;

fn main(){
    let teams = vec![String::from("Blue"),String::from("Yellow")];
    let inital_scores = vec![10,50];
    let scores: HashMap<_,_> = teams.iter().zip(inital_scores.iter()).collect();
}

use std::collections::HashMap;

fn main(){
    let name = String::from("overflow");
    let value = String::from("Blue");
    let mut s = HashMap::new();
    s.insert(name,value);
    // 错误，name被移动
    // println!("{}",name);
    // println!("{}",value);
}

use std::collections::HashMap;

fn main(){
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"),10);
    scores.insert(String::from("Yellow"),50);
   
    let score = scores.get(&String::from("Blue"));
    match score{
        Some(val)=>println!("{}",val),
        None => println!("None"),
   }
}

use std::collections::HashMap;

fn main(){
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"),10);
    scores.insert(String::from("Yellow"),50);

    for(k,v) in &scores{
        println!("{}:{}",k,v);
    }  
}

use std::collections::HashMap;

fn main(){
    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);
}

// entry()返回值
/// Returns a reference to the value corresponding to the key.

enum Result<T,E>{
    Ok(T),
    Err(E),
}
// T:操作成功时，Ok变体里返回的数据的类型
// E:操作失败时，Err变体里面返回的错误类型

use std::fs::File;
use std::io::ErrorKind;


fn main(){
    // match 表达式
    let f =match  File::open("hello.txt"){
        Ok(file)=>file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt"){
                Ok(fc) => fc,
                Err(e) => panic!("Error creating file {:?}",e),
            },
                other_error => panic!("Error opening the file: {:?}", other_error),
        },
    };

    // unwarp 表达式
    let f = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error|{
                panic!("Error creating file :{:?}", error);
            })
        } else {
            panic!("Error opening file: {:?}", error);
        }
    });
    
    // expect表达式
     let f = File::open("hello.txt").expect("无法打开文件");
}

use std::fs::File;
use std::io;
use std::io::Read;

fn main(){
    let s = match read_username_from_file("hello.txt"){
        Ok(s) => s,
        Err(e) => {
            panic!("the error is {:?}",e);
        },
    };

    println!("{}",s);
}

fn read_username_from_file(path: &str) -> Result<String, io::Error>{
    let f = File::open(path);

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

use std::fs::File;
use std::io;
use std::io::Read;

fn main(){
    let s = match read_username_from_file("hello.txt"){
        Ok(s) => s,
        Err(e) => {
            panic!("the error is {:?}",e);
        },
    };

    println!("{}",s);
}

fn read_username_from_file(path: &str) -> Result<String, io::Error>{
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

// 链式调用
fn read_username_from_file(path: &str) -> Result<String, io::Error>{
    let mut s = String::new();
    File::open(path)?.read_to_string(&mut s)?;
    Ok(s)
}

//例如
fn largest<T>(list:&[T])->T{}

// Struct泛型
struct Point<T>{
    x:T,
    y:T,
}

//enum泛型
enum Result<T,E>{
    Ok(T),
    Err(E),
}

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

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

// 类似于偏特化
impl  Point<i32>{
    fn x1(&self) -> &i32{
        &self.x
    }
}

#[derive(Debug)]
struct Point<T,U>{
    x:T,
    y:U,
}

impl<T,U> Point<T,U>{
    fn mixup<V,W>(self,other : Point<V,W>) -> Point<T,W>{
        Point{
            x:self.x,
            y:other.y,
        }
    }
}

fn main(){
    let p1 = Point{x:5, y:4};
    let p2 = Point{x:"Hello", y:'c'};
    let p3 = p1.mixup(p2);

    println!("{:#?}",p3);
}

pub trait Summary{
    fn summarize(&self) -> String;
    fn foo(&self) -> String;
}

// @File:lib.rs
pub trait Summary{
    fn summarize(&self) -> String;
}

pub struct NewsArticle{
    pub headline : String,
    pub location : String,
    pub auther   : String,
    pub content  : String,
}

// 实现tarit
impl Summary for NewsArticle{
    fn summarize(&self) -> String{
     format!("{}, by {} ({})",self.headline, self.auther, self.location)
    }
}

pub struct Tweet{
    pub username : String,
    pub content  : String,
    pub reply    : bool,
    pub retweet  : bool,
}

impl Summary for Tweet{
    fn summarize(&self) -> String{
        format!("{}: {}",self.username, self.content)
    }
}

//@File:main.rs
use rust_learn::Summary;
use rust_learn::Tweet;

fn main(){
    let tweet = Tweet{
        username : String::from("violet"),
        content :String::from("keep learn"),
        reply : false,
        retweet: false,
    };
    
    println!("1 new tweet: {}", tweet.summarize());

}

// @File:lib.rs
pub trait Summary{
    fn summarize(&self) -> String{
        // summarize有默认实现
        String::from("(Read more ...)")
    }
}

pub struct NewsArticle{
    pub headline : String,
    pub location : String,
    pub auther   : String,
    pub content  : String,
}

// 实现tarit
impl Summary for NewsArticle{
    fn summarize( headline: String::from("this is demo"),
        content: String::from("ababab"),
        auther: String::from("ice"),
        location: String::from("China"),&self) -> String{
     // 对默认实现的重写
     format!("{}, by {} ({})",self.headline, self.auther, self.location)
    }
}

pub struct Tweet{
    pub username : String,
    pub content  : String,
    pub reply    : bool,
    pub retweet  : bool,
}

impl Summary for Tweet{
    // fn summarize(&self) -> String{
    //     format!("{}: {}",self.username, self.content)
    // }
}

// @File:main.rs
use rust_learn::Summary;
use rust_learn::NewsArticle;
use rust_learn::Tweet;

fn main(){
    let tweet = Tweet{
        username : String::from("violet"),
        content :String::from("keep learn"),
        reply : false,
        retweet: false,
    };

    let article = NewsArticle{
        headline: String::from("this is demo"),
        content: String::from("ababab"),
        auther: String::from("ice"),
        location: String::from("China"),
    };
    
    println!("1 new tweet: {}", tweet.summarize());
    println!("1 new article: {}", article.summarize());

}

/************ out ************************/
// 1 new tweet: (Read more ...)
// 1 new article: this is demo, by ice (China)

// @File:lib.rs
pub trait Summary{
    fn summarize(&self) -> String{
        format!("Read more from{}...", self.summarize_auther())
    }
	// summarize_auther没有默认实现
    fn summarize_auther(&self) -> String;
}

pub struct NewsArticle{
    pub headline : String,
    pub location : String,
    pub auther   : String,
    pub content  : String,
}

// 实现tarit
impl Summary for NewsArticle{
    //只有实现summarize_auther才可调用summarize
    fn summarize_auther(&self) -> String{
        format!("@{}",self.auther)
    }
}

// @File:main.rs
use rust_learn::Summary;
use rust_learn::NewsArticle;

fn main(){

    let article = NewsArticle{
        headline: String::from("this is demo"),
        content: String::from("ababab"),
        auther: String::from("ice"),
        location: String::from("China"),
    };
    
    println!("1 new article: {}", article.summarize());

}