【不定期更新】一些简单的Rust程序

1. Hello, world!

fn main() {
    println!("Hello, world!");
}

2. 输入姓名并问候

use std::io::{Write, stdin, stdout};

fn main() {
    let mut s = String::new();

    print!("What is your name? ");

    if let Err(e) = stdout().flush().and(stdin().read_line(&mut s)) {
        panic!("{}", e);
    }

    match s.trim() {
        n if n.is_empty() => println!("No name entered."),
        n => println!("Hello, {}!", n),
    }
}

3. 生成随机数

extern "C" {
    fn rand() -> i32;
    fn srand(seed: u32);
    fn time(arg: *mut isize) -> isize;
}

fn main() {
    let mut v = vec![0; 20];

    unsafe {
        srand(time(0 as _) as _);
    }

    for x in &mut v {
        *x = unsafe { rand() } % 90 + 10;
    }
    v.sort();
    println!("{:?}", v);

    v.retain(|&x| x >= 50);
    println!("{:?}", v);
}

4. 输出美国部分城市及其所在州

macro_rules! hash_map {
    ($($k:expr => $v:expr),*) => ({
        let mut m = ::std::collections::hash_map::HashMap::new();
        $(m.insert($k, $v);)*
        m
    })
}

fn main() {
    let mut map = hash_map!["Seattle" => "California",
                            "Chicago" => "Illinois",
                            "New York" => "New York",
                            "Miami" => "Florida"];

    if let Some(state) = map.get_mut("Seattle") {
        *state = "Washington";
    }
    map.remove("New York");

    for (city, state) in &map {
        println!("{} => {}", city, state);
    }

    println!("Length = {}", map.len());
}

5. 包装 VecDeque<T>实现栈（Stack<T>）数据结构

use std::collections::VecDeque;
use std::fmt::{self, Debug, Formatter};

#[derive(Clone, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Stack<T> {
    vec_deque: VecDeque<T>,
}

impl<T> Stack<T> {
    #[inline]
    pub fn new() -> Stack<T> {
        Stack { vec_deque: VecDeque::new() }
    }

    #[inline]
    pub fn len(&self) -> usize {
        self.vec_deque.len()
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.vec_deque.is_empty()
    }

    #[inline]
    pub fn top(&self) -> Option<&T> {
        self.vec_deque.back()
    }

    #[inline]
    pub fn top_mut(&mut self) -> Option<&mut T> {
        self.vec_deque.back_mut()
    }

    #[inline]
    pub fn pop(&mut self) -> Option<T> {
        self.vec_deque.pop_back()
    }

    #[inline]
    pub fn push(&mut self, value: T) {
        self.vec_deque.push_back(value);
    }

    #[inline]
    pub fn vec_deque(&self) -> &VecDeque<T> {
        &self.vec_deque
    }

    #[inline]
    pub fn vec_deque_mut(&mut self) -> &mut VecDeque<T> {
        &mut self.vec_deque
    }
}

impl<T: Debug> Debug for Stack<T> {
    #[inline]
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        (&self.vec_deque as &Debug).fmt(f)
    }
}

impl<T> From<VecDeque<T>> for Stack<T> {
    #[inline]
    fn from(other: VecDeque<T>) -> Stack<T> {
        Stack { vec_deque: other }
    }
}

fn main() {
    let mut s = Stack::new();

    s.push("Hello");
    s.push("world!");
    s.push("CHAOS");

    println!("{:?}", s);
    println!("{}", s.len());

    while !s.is_empty() {
        if let Some(x) = s.pop() {
            println!("Popped: {}", x);
        }
    }
}