use std::alloc::{GlobalAlloc, System, Layout};

struct MyAllocator;

unsafe impl GlobalAlloc for MyAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        System.alloc(layout)
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        System.dealloc(ptr, layout)
    }
}

#[global_allocator]
static GLOBAL: MyAllocator = MyAllocator;

fn main() {
    // 使用 GLOBAL 内存分配器
    let mut v = Vec::new();
    v.push(1);
}

// 使用 jemalloc 内存分配器
use jemallocator::Jemalloc;

#[global_allocator]
static GLOBAL: Jemalloc = Jemalloc; // Jemalloc 是 unit struct 类型

fn main() {}

pub unsafe trait Allocator {
    // Required methods
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
    //...
}

pub struct Layout { /* private fields */ }

// 创建 T 类型的 Layout
pub const fn new<T>() -> Layout
// 从 T 的 value 创建 Layout
pub fn for_value<T>(t: &T) -> Layout where T: ?Sized
pub unsafe fn for_value_raw<T>(t: *const T) -> Layout where T: ?Sized
pub const fn from_size_align(size: usize, align: usize ) -> Result<Layout, LayoutError>
pub const unsafe fn from_size_align_unchecked( size: usize, align: usize ) -> Layout

// 获得 Layout 的 size 和 align 信息
pub const fn size(&self) -> usize
pub const fn align(&self) -> usize
pub fn dangling(&self) -> NonNull<u8>
pub fn align_to(&self, align: usize) -> Result<Layout, LayoutError>
pub fn padding_needed_for(&self, align: usize) -> usize
pub fn pad_to_align(&self) -> Layout
pub fn repeat(&self, n: usize) -> Result<(Layout, usize), LayoutError>
pub fn extend(&self, next: Layout) -> Result<(Layout, usize), LayoutError>
pub fn repeat_packed(&self, n: usize) -> Result<Layout, LayoutError>
pub fn extend_packed(&self, next: Layout) -> Result<Layout, LayoutError>
pub fn array<T>(n: usize) -> Result<Layout, LayoutError>

// Allocate memory with the global allocator.
pub unsafe fn alloc(layout: Layout) -> *mut u8

  use std::alloc::{alloc, dealloc, handle_alloc_error, Layout};
  unsafe {
      let layout = Layout::new::<u16>();
      // ptr 是 *mut u8 类型
      let ptr = alloc(layout);
      if ptr.is_null() {
          handle_alloc_error(layout);
      }

      *(ptr as *mut u16) = 42;
      assert_eq!(*(ptr as *mut u16), 42);

      dealloc(ptr, layout);
  }

// Allocate zero-initialized memory with the global allocator.
pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8

  use std::alloc::{alloc_zeroed, dealloc, Layout};
  unsafe {
      let layout = Layout::new::<u16>();
      let ptr = alloc_zeroed(layout);

      assert_eq!(*(ptr as *mut u16), 0);

      dealloc(ptr, layout);
  }

// Deallocate memory with the global allocator.
pub unsafe fn dealloc(ptr: *mut u8, layout: Layout)

// Reallocate memory with the global allocator.
pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8

// Registers a custom allocation error hook, replacing any that was previously registered.
pub fn set_alloc_error_hook(hook: fn(_: Layout))

  // 开启实验特性 alloc_error_hook
  #![feature(alloc_error_hook)]
  use std::alloc::{Layout, set_alloc_error_hook};
  fn custom_alloc_error_hook(layout: Layout) {
      panic!("memory allocation of {} bytes failed", layout.size());
  }
  set_alloc_error_hook(custom_alloc_error_hook);

// https://github.com/tokio-rs/tokio/issues/6760
use std::alloc::{GlobalAlloc, Layout};

/// 自定义的内存分配器的追踪器
struct TrackedAlloc;

#[global_allocator]
static ALLOC: TrackedAlloc = TrackedAlloc;

/// 内部追踪内存的具体实现
unsafe impl GlobalAlloc for TrackedAlloc {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let ret = REAL_ALLOCATOR.0.alloc(layout);
        if !ret.is_null() {
            INNER_MEMORY.fetch_add(layout.size(), Ordering::Relaxed);
        }
        ret
    }
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        REAL_ALLOCATOR.0.dealloc(ptr, layout);
        INNER_MEMORY.fetch_sub(layout.size(), Ordering::Relaxed);
    }

    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
        let ret = REAL_ALLOCATOR.0.alloc_zeroed(layout);
        if !ret.is_null() {
            INNER_MEMORY.fetch_add(layout.size(), Ordering::Relaxed);
        }
        ret
    }
    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
        let ret = REAL_ALLOCATOR.0.realloc(ptr, layout, new_size);
        if !ret.is_null() {
            INNER_MEMORY.fetch_add(new_size.wrapping_sub(layout.size()), Ordering::Relaxed);
        }
        ret
    }
}

assert_eq!(std::any::type_name::<Option<String>>(), "core::option::Option<alloc::string::String>",);

use std::any::type_name_of_val;
let s = "foo";
let x: i32 = 1;
let y: f32 = 1.0;
assert!(type_name_of_val(&s).contains("str"));
assert!(type_name_of_val(&x).contains("i32"));
assert!(type_name_of_val(&y).contains("f32"));

pub trait Any: 'static {
    fn type_id(&self) -> TypeId;
}

let my_i8 = 1i8;
let _myi8 = &my_i8 as &dyn Any;
// 合法，因为:
// - i8 是一个具有所有权的类型，它满足 'static 约束
// - 虽然 `my_i8` 本身的生命周期是有限的，但 i8 类型本身满足 'static
// - `&dyn Any` 中的引用可以有任意生命周期，不需要是 'static

let x = 42i32;  // i32 满足 'static
let _ = &x as &dyn Any;  // 可以

let s = String::from("hello");  // String 满足 'static
let _ = &s as &dyn Any;  // 可以

// 这个是不合法的
let mut value = String::new();
let ref_to_value = &value; // ref_to_value 是借用
let _ = ref_to_value as &dyn Any;  // 编译错误，因为引用类型本身不满足 'static

use std::fmt::Debug;
use std::any::Any;

// Logger function for any type that implements `Debug`.
// T 实现了 Any，它是一个非借用的值类型，由于 T 实现了 dyn Any， 所以 &T 可以转换为 &dyn Any;
// 但是如果 T 是借用类型，则 &T 必须是 'static 类型的借用。
fn log<T: Any + Debug>(value: &T) {
    // 将借用转换为 &dyn Any
    let value_any = value as &dyn Any;

    match value_any.downcast_ref::<String>() {
        Some(as_string) => {
            println!("String ({}): {}", as_string.len(), as_string);
        }
        None => {
            println!("{value:?}");
        }
    }
}

// This function wants to log its parameter out prior to doing work with it.
fn do_work<T: Any + Debug>(value: &T) {
    log(value);
    // ...do some other work
}

fn main() {
    let my_string = "Hello World".to_string();
    do_work(&my_string);

    let my_i8: i8 = 100;
    do_work(&my_i8);
}

// 例子
use std::any::{Any, TypeId};

fn is_string<T: ?Sized + Any>(_s: &T) -> bool {
    TypeId::of::<String>() == TypeId::of::<T>()
}
assert_eq!(is_string(&0), false);
assert_eq!(is_string(&"cookie monster".to_string()), true);

use std::any::Any;

fn is_string(s: &dyn Any) {
    if s.is::<String>() {
        println!("It's a string!");
    } else {
        println!("Not a string...");
    }
}
is_string(&0);
is_string(&"cookie monster".to_string());

fn modify_if_u32(s: &mut dyn Any) {
    if let Some(num) = s.downcast_mut::<u32>() {
        *num = 42;
    }
}

let mut x = 10u32;
let mut s = "starlord".to_string();
modify_if_u32(&mut x);
modify_if_u32(&mut s);
assert_eq!(x, 42);
assert_eq!(&s, "starlord");

pub fn capture() -> Backtrace // 受环境变量调控
pub fn force_capture() -> Backtrace // 强制捕获

pub const fn disabled() -> Backtrace // 关闭捕获
pub fn status(&self) -> BacktraceStatus  // 返回是否开启了 Backtrace 捕获
pub fn frames(&'a self) -> &'a [BacktraceFrame]

// 示例
use std::backtrace::Backtrace

fn main() {
    let bt  = Backtrace::force_capture();
    println!("{}", bt); // Backtrace 实现了 Debug 和 Display，打印调用栈。
}

// 在栈上创建一个 1000 个 i32 类型元素的数组
let a = [0; 1000];
// 转移数组的所有权到 a2，由于 a 分配在栈上，这里做了一次栈内存拷贝
let a2 = a;

// 在堆上分配一个数组，ab 的栈内存为 usize 大小的指针
let ab = Box::new([0; 1000]);
// 转移 ab 的所有权到 ab2，只是一个 usize 内存的拷贝，堆内存没有拷贝
let ab2 = ab;

pub struct Box<T, A = Global>(/* private fields */) where A: Allocator, T: ?Sized;

let val: u8 = 5; // 栈上分配内存
let boxed: Box<u8> = Box::new(val); // 堆上分配内存

// 使用 Box 保存递归数据类型对象
#[allow(dead_code)]
#[derive(Debug)]
enum List<T> {
    Cons(T, Box<List<T>>),
    Nil,
}

let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
println!("{list:?}");

let _b: Box<dyn std::fmt::Display> = Box::new(123i32);

// trait object 的两种形式:

// 1. &dyn Trait, &(dyn Trait + 'static + Send + Sync)，使用对象引用赋值。
let dsd: &dyn std::fmt::Display = &1i32;

// 2. Box<dyn Trait>，使用对象赋值。
let bo: Box<dyn std::fmt::Display> = Box::new(1i32);
let bo: Box<dyn std::any::Any> = Box::new(1i32);
let bo: Box<&dyn std::fmt::Display> = Box::new(&1i32);

// 以下是 CoerceUnsized trait 实现的 type coercion 转换, 将 &T 隐式转换为 &U（U 必须是 unsized type）.
// 常见的 U 类型：1. trait object；2. slice [T];
//
// 当 T 可以 CoerceUnsized 到 U 时，支持 Box<T> -> Box<U>
//
let bo: Box<[i32]> = Box::new([1, 2, 3]); // [T; N] -> [T]
let b1 = Box::new(123i32); // i32 -> dyn std::fmt::Display
let b2: Box<dyn std::fmt::Display> = b1;

use std::any::Any;

fn print_if_string(value: Box<dyn Any + Send + Sync>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));

use std::mem;

#[allow(dead_code)]
#[derive(Debug, Clone, Copy)]
struct Point {
    x: f64,
    y: f64,
}

#[allow(dead_code)]
struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

fn origin() -> Point {
    Point { x: 0.0, y: 0.0 }
}

fn boxed_origin() -> Box<Point> {
    // 在堆上分配 Point
    Box::new(Point { x: 0.0, y: 0.0 })
}

enum List {
    // 元组类型，由于 Box 没有实现 Copy，所以整个元组没有实现 Copy
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));

    // a 所有权转移。这里不能传入 &a, 否则只是分配一个指针的空间。
    let b = Cons(3, Box::new(a));

    // 编译器报错，解决办法是使用 Rc<T>
    // let c = Cons(4, Box::new(a));
}

let boxed: Box<u8> = Box::new(5);
let val: u8 = *boxed;

fn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let x = 5;
    let y = Box::new(x);
    assert_eq!(5, *y); // *y 等效为 *(y.deref()), 返回 5。

    let boxed: Box<u8> = Box::new(5);
    let val: u8 = *boxed;

    let m = MyBox::new(String::from("Rust"));
    // Rust 自动进行多级 Defer 解引用，也就是 deref coercion：
    //   MyBox<String> -> String -> str
    hello(&m);

    // 如果 Rust 不做 deref coercion，则需要做如下繁琐操作
    hello(&(*m)[..]);
}


// values 类型：Box<[MaybeUninit<u32>]>
let mut values = Box::<[u32]>::new_uninit_slice(3);
// Deferred initialization:
values[0].write(1); // [MaybeUninit<u32>] 是 slice，支持 Index 操作
values[1].write(2);
values[2].write(3);
let values = unsafe {values.assume_init() };

assert_eq!(*values, [1, 2, 3])

/* C header */

/* Returns ownership to the caller */
struct Foo* foo_new(void);

/* Takes ownership from the caller; no-op when invoked with null */
void foo_delete(struct Foo*);

#[repr(C)]
pub struct Foo;

// `#[no_mangle]` 表示不对 Rust 函数名进行混淆，这样 C 一侧可以直接用 Rust 函数名来调用它。
#[no_mangle]
pub extern "C" fn foo_new() -> Box<Foo> {
    Box::new(Foo)
}

// foo_delete() 的参数可能是 nullable 指针，而 Box<Foo> 不可能是 null，故需要使用 Option
#[no_mangle]
pub extern "C" fn foo_delete(_: Option<Box<Foo>>) {}

let value = &mut 32 as *mut i32;
let box = Box::<i32>::from_raw(value);

let value2 = &*box as *const i32;

pub fn leak<'a>(b: Box<T, A>) -> &'a mut T where A: 'a,

let x = Box::new(41);
let static_ref: &'static mut usize = Box::leak(x);
*static_ref += 1;
assert_eq!(*static_ref, 42);

impl<'a> From<&str> for Box<dyn Error + 'a>
impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

impl<T, A> Unpin for Box<T, A> where A: Allocator, T: ?Sized,
impl<T, A> Send for Box<T, A> where A: Send, T: Send + ?Sized,
impl<T, A> Sync for Box<T, A> where A: Sync, T: Sync + ?Sized,

impl<T> !Sync for Cell<T> where T: ?Sized,

impl<T> Send for Cell<T> where T: Send + ?Sized,
impl<T> Unpin for Cell<T> where T: Unpin + ?Sized,

impl<T> Cell<T>
pub const fn new(value: T) -> Cell<T> //转移 value 对象的所有权；
pub fn set(&self, val: T) //将内部的对象替换为传入的 value；
pub fn swap(&self, other: &Cell<T>)
pub const fn replace(&self, val: T) -> T
pub const fn into_inner(self) -> T

// get/update 方法的 T 必须实现 Copy
impl<T> Cell<T> where T: Copy,
pub const fn get(&self) -> T // 调用对象实现的 Copy trait，返回一个新对象 T
pub fn update(&self, f: impl FnOnce(T) -> T)


impl<T> Cell<T> where T: ?Sized,
pub const fn as_ptr(&self) -> *mut T
pub const fn get_mut(&mut self) -> &mut T
pub const fn from_mut(t: &mut T) -> &Cell<T>

impl<T> Cell<T> where T: Default,
pub fn take(&self) -> T


// 示例：
use std::cell::Cell;

pub struct SpiderRobot {
    // ...
    hardware_error_count: Cell<u32>,
    // ...
}

impl SpiderRobot {
    pub fn add_hardware_error(&self) {
        let n = self.hardware_error_count.get();
        // 内部可变性：可以通过 &T 类型的 self 来修改 hardware_error_count 内部的值
        self.hardware_error_count.set(n + 1);
    }

    pub fn has_hardware_errors(&self) -> bool {
        self.hardware_error_count.get() > 0
    }
}

impl<T> Clone for Cell<T> where T: Copy,
impl<T> Debug for Cell<T> where T: Copy + Debug,
impl<T> Default for Cell<T> where T: Default,

impl<T> !Sync for Cell<T> where T: ?Sized,
impl<T> Send for Cell<T> where T: Send + ?Sized,
impl<T> Unpin for Cell<T> where T: Unpin + ?Sized,

// 意味着： 只要 T 可以 unsize 转换为 U，则 Cell<T> 可以隐式的自动转换为 Cell<U> ，如 Cell<i32> -> Cell<dyn Display>
// Unsize trait：https://doc.rust-lang.org/std/marker/trait.Unsize.html
impl<T, U> CoerceUnsized<Cell<U>> for Cell<T> where T: CoerceUnsized<U>,

impl<T> RefCell<T>
pub const fn new(value: T) -> RefCell<T>
pub const fn into_inner(self) -> T
pub fn replace(&self, t: T) -> T
pub fn replace_with<F>(&self, f: F) -> T where F: FnOnce(&mut T) -> T,
pub fn swap(&self, other: &RefCell<T>)

impl<T> RefCell<T> where T: ?Sized,
pub fn borrow(&self) -> Ref<'_, T>  // 共享借用，Ref 内部持有 T 的共享借用，所以有 lifetime，是智能指针，如果调用时已经被 borrow_mut() 则 panic
pub fn try_borrow(&self) -> Result<Ref<'_, T>, BorrowError>
pub fn borrow_mut(&self) -> RefMut<'_, T> // 可变借用，RefMut 内部持有 T 的可变借用，所以有 lifetime，是智能指针，如果调用时已经被 borrow() 则 panic
pub fn try_borrow_mut(&self) -> Result<RefMut<'_, T>, BorrowMutError>
pub fn as_ptr(&self) -> *mut T
pub fn get_mut(&mut self) -> &mut T
pub const fn undo_leak(&mut self) -> &mut T
pub unsafe fn try_borrow_unguarded(&self) -> Result<&T, BorrowError>

impl<T> RefCell<T> where T: Default,
pub fn take(&self) -> T


// 示例：
use std::cell::RefCell;

let ref_cell: RefCell<String> =  RefCell::new("hello".to_string());

let r = ref_cell.borrow();
let count = r.len();
assert_eq!(count, 5);

let mut w = ref_cell.borrow_mut(); // panic: already borrowed
w.push_str(" world");

pub struct SpiderRobot {
    // ...
    log_file: RefCell<File>,
    // ...
}

impl SpiderRobot {
    pub fn log(&self, message: &str) {
        let mut file = self.log_file.borrow_mut(); // file 是 RefMut<&str> 类型
        writeln!(file, "{}", message).unwrap();
    }
}

use std::cell::RefCell;

let c = RefCell::new(5);
let m = c.borrow();

let b = c.borrow_mut(); // this causes a panic

impl<T> Deref for RefMut<'_, T> where T: ?Sized,
impl<T> DerefMut for RefMut<'_, T> where T: ?Sized,

// 没有实现 Send 和 Sync，故智能在当前线程中使用
impl<'b, T> !Send for RefMut<'b, T>
impl<'b, T> !Sync for RefMut<'b, T>

use std::cell::{RefCell, RefMut};
use std::collections::HashMap;
use std::rc::Rc;

fn main() {
    let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
    // Create a new block to limit the scope of the dynamic borrow
    {
        // RefMut 持有 &mut T，所以是具有 lifetime 的智能指针对象，
        let mut map: RefMut<'_, _> = shared_map.borrow_mut();
        map.insert("africa", 92388);
        map.insert("kyoto", 11837);
        map.insert("piccadilly", 11826);
        map.insert("marbles", 38);
    }

    // Note that if we had not let the previous borrow of the cache fall out
    // of scope then the subsequent borrow would cause a dynamic thread panic.
    // This is the major hazard of using `RefCell`.
    let total: i32 = shared_map.borrow().values().sum();
    println!("{total}");
}

impl<T> Clone for RefCell<T> where T: Clone,
impl<T> Debug for RefCell<T> where T: Debug + ?Sized,
impl<T> Default for RefCell<T> where T: Default,
impl<T> Send for RefCell<T> where T: Send + ?Sized,
impl<T> !Sync for RefCell<T> where T: ?Sized,
impl<T> Unpin for RefCell<T> where T: Unpin + ?Sized,

use std::cell::OnceCell;

let cell = OnceCell::new();

// get() 返回 Option，如果未设置则返回 None
assert!(cell.get().is_none());

// cell 虽然没加 mut，但具有内部可变性。
let value: &String = cell.get_or_init(|| {
    "Hello, World!".to_string() // 闭包返回保存的内部对象值，get_or_init() 返回它的借用。
});
assert_eq!(value, "Hello, World!");
assert!(cell.get().is_some());

// set(): 如果已设置，则返回 Err
let cell = OnceCell::new();
assert!(cell.get().is_none());
assert_eq!(cell.set(92), Ok(()));
assert_eq!(cell.set(62), Err(62));
assert!(cell.get().is_some());

impl<T> !Sync for OnceCell<T>
impl<T> Send for OnceCell<T> where T: Send,
impl<T> Unpin for OnceCell<T> where T: Unpin,

use std::cell::LazyCell;

let lazy: LazyCell<i32> = LazyCell::new(|| {
    println!("initializing");
    92
});
println!("ready");
println!("{}", *lazy);
println!("{}", *lazy);

impl<T, F> Deref for LazyCell<T, F> where F: FnOnce() -> T,
impl<T, F> DerefMut for LazyCell<T, F> where F: FnOnce() -> T,

impl<T, F> Send for LazyCell<T, F> where F: Send, T: Send,
impl<T, F = fn() -> T> !Sync for LazyCell<T, F>
impl<T, F> Unpin for LazyCell<T, F> where F: Unpin, T: Unpin,

use std::cell::{RefCell, RefMut};
use std::collections::HashMap;
use std::rc::Rc;

fn main() {
    let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));

    // Create a new block to limit the scope of the dynamic borrow
    {
        let mut map: RefMut<'_, _> = shared_map.borrow_mut();
        map.insert("africa", 92388);
        map.insert("kyoto", 11837);
        map.insert("piccadilly", 11826);
        map.insert("marbles", 38);
    }

    // Note that if we had not let the previous borrow of the cache fall out
    // of scope then the subsequent borrow would cause a dynamic thread panic.
    // This is the major hazard of using `RefCell`.
    let total: i32 = shared_map.borrow().values().sum();
    println!("{total}");
}

// 多线程安全的全局对象
static GLOBL :Arc<Mutex<i32>> = Arc::new(Mutex::New(1));

let vec = vec![1, 2, 3, 4];
for x in vec.iter() {
   println!("vec contained {x:?}");
}

let mut vec = vec![1, 2, 3, 4];
for x in vec.iter_mut() {
   *x += 1;
}

// 创建一个空的 vector, len/capacity 均为 0
let mut numbers: Vec<i32> = vec![];

// 用给定的内容创建一个vector, len/capacity 等于元素数目
let words = vec!["step", "on", "no", "pets"];
let mut buffer = vec![0u8; 1024]; // 1024 个 0字节

// 将 set 转换成 Vec
let my_vec = my_set.into_iter().collect::<Vec<String>>();

// 获取一个元素的引用
let first_line = &lines[0];

// 获取一个元素的拷贝
let fifth_number = numbers[4];
let second_number = lines[1].clone();

// 获取一个切片的引用
let my_ref = &buffer[4..12];

// 获取一个切片的拷贝：slice.to_vec(), Clone 切片生成 Vec
let my_copy = buffer[4..12].to_vec(); // Vec<T>
let v = [1, 2, 3, 4, 5, 6, 7, 8, 9];
assert_eq!(v.to_vec(), vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
assert_eq!(v[0..6].to_vec(), vec![1, 2, 3, 4, 5, 6]);

// 将 iterable 的所有 item 按顺序添加到 vec 的末尾。iterable 参数可以是任何实现了 IntoIterator<Item=T>。
vec.extend(iterable);

// 类似于 vec.truncate(index)，但返回一个 Vec 包含 index 及以后的元素, 原来的 vec 只包含 index 前的元素。
vec.split_off(index);

// 将 vec2 的内容添加到 vec, 然后 vec2 被清空. 类似于 vec.extend(vec2)，除了调用之后 vec2 仍然存在，并且容量不变。
vec.append(&mut vec2);

// 从 vec 中移除范围 vec[range]，并返回一个被移除元素的迭代器，其中 range 是一个范围值，例如 .. 或0..4。
vec.drain(range);

// 移除所有没有通过给定测试的方法。类似于 vec = vec.into_iter().filter(test).collect();
vec.retain(test);