rust学习笔记

use std::collections::btree_map::{self, BTreeMap};

fn pop(m: &mut BTreeMap<u32, Vec<u32>>, key: u32) -> Option<u32> {
    match m.entry(key) {
        btree_map::Entry::Occupied(mut entry) => {
            let values = entry.get_mut();
            let ret = values.pop();
            if values.is_empty() {
                entry.remove();
            }
            ret
        }
        btree_map::Entry::Vacant(_) => {
            None
        }
    }
}
fn main() {
    let mut m: BTreeMap<u32, Vec<u32>> = BTreeMap::new();
    m.insert(1, vec![2, 3]);
    assert_eq!(pop(&mut m, 1), Some(3));
    assert_eq!(pop(&mut m, 1), Some(2));
    assert!(m.is_empty());
}

pub fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>)

#[derive(Deserialize)]
struct Info {
    #[serde(rename = "num-run-op")]
    num_run_op: usize,
}

use std::ffi::CStr;
let c_buf: *const c_char = unsafe { hello() };
let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
let str_slice: &str = c_str.to_str().unwrap();
let str_buf: String = str_slice.to_owned();  // if necessary

use std::io;
use std::env;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let mut args = env::args();
    let arg0 = args.next().unwrap();
    // args.len(): Returns the exact remaining length of the iterator.
    if args.len() != 1 {
        eprintln!("{} dump-file", arg0);
        return Err(Box::new(io::Error::new(
            io::ErrorKind::Other,
            "Invalid arguments",
        )));
    }
    let file_path = args.next().unwrap();
    println!("{}", file_path);
    Ok(())
}

trait A {
    fn a() -> i32;
}
impl A for f32 {
    fn a() -> i32 {
        return 2333;
    }
}
fn main() {
    // 2333
    println!("{}", f32::a());
}

trait A {
    type T;
}

trait A {
    type T;
}
struct C<B: A, C = <B as A>::T> { a: B, at: C }

<T as TraitA>::method_name(xxx)

use std::ops::SubAssign;
fn func<T>(a: &mut T, b: &T)
where
    T: for<'a> SubAssign<&'a T>,
{
    *a -= b;
}
fn main() {
    let mut a = 2;
    let b = 1;
    func(&mut a, &b);
    println!("{}", a);
}

use std::error::Error;
fn main() -> Result<(), Box<dyn Error>> {

enum FlushError {
    Bincode(bincode::Error),
    Io(io::Error),
}
impl From<bincode::Error> for FlushError {
    fn from(e: bincode::Error) -> Self {
        Self::Bincode(e)
    }
}
impl From<io::Error> for FlushError {
    fn from(e: io::Error) -> Self {
        Self::Io(e)
    }
}

fn main() {
    let mut a = vec![0, 1, 2, 3, 4, 5];
    let mut iter = a.iter_mut();
    let a1 = iter.nth(1).unwrap();
    let a3 = iter.nth(3 - 1 - 1).unwrap();
    *a1 = -1;
    *a3 = -1;
    println!("{:?}", a);
}

#![feature(get_many_mut)]
fn main() {
    let mut a = vec![0, 1, 2, 3, 4, 5];
    let [a1, a3] = a.get_many_mut([1, 3]).unwrap();
    *a1 = -1;
    *a3 = -1;
    println!("{:?}", a);
}

#[cfg(test)]
impl Default for Status {

fn last_or_push<'a>(vec: &'a mut Vec<String>) -> &'a String {
    if let Some(s) = vec.last() { // borrows vec
        // returning s here forces vec to be borrowed
        // for the rest of the function, even though it
        // shouldn't have to be
        return s;
    }

    // Because vec is borrowed, this call to vec.push gives
    // an error!
    vec.push("".to_string()); // ERROR
    vec.last().unwrap()
}

fn last_or_push<'a>(vec: &'a mut Vec<String>) -> &'a String {
    if !vec.is_empty() {
        let s = vec.last().unwrap(); // borrows vec
        return s; // extends the borrow
    }

    // In this branch, the borrow has never happened, so even
    // though it is extended, it doesn't cover this call;
    // the code compiles.
    //
    // Note the subtle difference with the previous example:
    // in that code, the borrow *always* happened, but it was
    // only *conditionally* returned (but the compiler lost track
    // of the fact that it was a conditional return).
    //
    // In this example, the *borrow itself* is conditional.
    vec.push("".to_string());
    vec.last().unwrap()
}

fn main() { }

struct ThreadSafePtr<T>(*mut T);
unsafe impl<T> Send for ThreadSafePtr<T> {}
unsafe impl<T> Sync for ThreadSafePtr<T> {}

struct S<'a> {
    m: &'a mut i32,
}
impl<'a> S<'a> {
    fn f1<'b>(&'b mut self) -> &'a mut i32 {
        let new_m: &'a mut i32 = self.m;
        new_m
    }
}
fn f2(m: &mut i32) -> &mut i32 {
    let mut s = S { m };
    s.f1()
}
fn main() {
    let mut m = 2;
    *f2(&mut m) = 3;
    println!("{}", m);
}

struct S<'a> {
    m: &'a mut i32,
}
impl<'a> S<'a> {
    fn f1(self) -> &'a mut i32 {
        let new_m: &'a mut i32 = self.m;
        new_m
    }
}
fn f2(m: &mut i32) -> &mut i32 {
    let s = S { m };
    s.f1()
}
fn main() {
    let mut m = 2;
    *f2(&mut m) = 3;
    println!("{}", m);
}

struct S<'a> {
    m: &'a i32,
}
impl<'a> S<'a> {
    fn f1<'b>(&'b self) -> &'a i32 {
        let new_m: &'a i32 = self.m;
        new_m
    }
}
fn f2(m: &i32) -> &i32 {
    let s = S { m };
    s.f1()
}
fn main() {
    let m = 2;
    println!("{}", f2(&m));
}

struct S<'a> {
    m: &'a mut i32,
}
impl<'a> S<'a> {
    fn f1<'b>(&'b self) -> &'a i32 {
        let new_m: &'a i32 = self.m;
        new_m
    }
}
fn f2(m: &mut i32) -> &i32 {
    let s = S { m };
    s.f1()
}
fn main() {
    let mut m = 2;
    println!("{}", f2(&mut m));
}

fn f1<'b>(self) -> &'a i32 {