fn add(i: i32, j: i32) -> i32 { i + j + out}

# 注释 Basic usage: ``` /// # 文档注释: Sum函数 /// 该函数为求和函数 /// # usage: /// assert_eq!(3, sum(1, 2)); fn sum(a: i32, b: i32) -> i32 { a + b } pub fn an

# answer Basic usage: ``` // extern crate std; // 声明语句 // use std::prelude::v1::*; // 声明语句 pub fn answer() -> (){ let a = 40; // 声明语句 let b

# 使用Any进行反射 Basic usage: 使用is函数进行类型判断 ``` use std::any::{Any, TypeId}; enum E { H, He, Li} struct S { x: u8, y: u8, z: u16 } fn main() { let v1 =

# 基本数据类型：array类型 Basic usage: ``` fn array_type() { let arr: [i32; 3] = [1, 2, 3]; // 定义一个[i32; 3]类型的数组，默认不可变 let mut mut_arr = [1, 2, 3];

# trait: 关联类型 Base usage: ``` pub fn associated_type(){ #[derive(Debug, PartialEq)] struct Foo(i32); #[derive(Debug, PartialEq)] struct Bar(i32, i32

# 原子类型 Basic usage: 使用原子类型实现自旋锁 ```rust use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; use std::thread; fn main() { let spinloc

# 类型转换：自动解引用（For SmartPointer） Base usage: `Vec<T>`实现了`Deref<Target=[T]>` ``` fn foo(s: &[i32]){ println!("{:?}", s[0]); } let v = vec![1,2,3]; foo

# 字符串编码 Base usage: 从Unicode到UTF-8编码过程 ```rust use std::str; fn main() { let tao = str::from_utf8(&[0xE9u8, 0x81u8, 0x93u8]).unwrap(); // 将UTF-8序列转为

# 优先队列：BinaryHeap Basic usage: ``` use std::collections::BinaryHeap; fn binary_heap() { let mut heap = BinaryHeap::new(); assert_eq!(heap.peek(), No

# 资源管理： Base usage: 变量与函数 变量默认存储在栈中 ``` fn main() { let x: i32; // Rust会检查未初始化的变量，并报错 println!("{}", x); } ``` Base usage: if 分支检查 ``` fn main() {

# 基本数据类型：布尔值 Basic usage: ``` fn bool_type() { let x = true; // bool类型可以自动推断 let y: bool = false; // bool值分为true和false let x = 5; if x > 1 { print

# 借用与引用 Base usage: 为函数传递数组，使用可变绑定作为参数 因为传入的是不可变，而经过函数参数的模式匹配，成为了可变参数 ```rust fn foo(mut v: [i32; 3]) -> [i32; 3] { v[0] = 3; assert_eq!([3,2,3], v);

# 借用检查 Base usage: 借用检查保证了内存安全 试想，input 和 output 如果将同一个变量的 不可变和可变引用同时传入会发生什么？ ```rust fn compute(input: &u32, output: &mut u32) { if *input > 10 { o

# NLL： 非词法作用域生命周期 以下代码目前在 Rust 2015版本中 会出错，但是选择Rust 2018 edition将正常编译 可以去play.rust-lang.org选择2018 edtion版本尝试 Base usage: 案例1 ```rust struct Foo; im

# 底类型：应用 Base usage ``` #![feature(never_type)] fn foo() -> ! { // do something loop { println!("jh"); } } let i = if false { foo(); } else { 100 };

# 智能指针：Box<T> Basic usage: ``` fn box_demo(){ #[derive(PartialEq, Debug)] struct Point { x: f64, y: f64, } // 将Point实例装箱（放到堆内存） let box_point = Box:

# 智能指针和所有权: Box<T> Base usage: Box<T>独占所有权 ```rust fn main(){ let x = Box::new("hello"); let y = x; // error[E0382]: use of moved value: `x` // prin

# 借用与引用 Base usage: 冒泡排序 ```rust fn bubble_sort(a: &mut Vec<i32>) { let mut n = a.len(); // 获取数组长度 while n > 0 { // 初始化遍历游标，max_ptr始终指向最大值 let (mut

# CSP并发模型 查看随书源码中的pow库，可以查看channel实现工作量证明的示例 Basic usage: 流通道channel示例 异步channel ```rust use std::thread; use std::sync::mpsc::channel; fn main()

# 基本数据类型：char类型 Basic usage: ``` fn char_type(){ let x = 'r'; let x = 'Ú'; println!("{}", '\''); println!("{}", '\\'); println!("{}", '\n'); println

# 闭包 Basic usage: ``` pub fn closure(){ let out = 42; // 普通函数 // fn add(i: i32, j: i32) -> i32 { i + j + out} fn add(i: i32, j: i32) -> i32 { i +

# 闭包生成类型 Base usage: Copy语义自动实现Fn ```rust fn main() { let s = "hello"; let c = ||{ println!("{:?}", s) }; c(); c(); println!("{:?}", s); } ``` Bas

# 闭包: 作为参数 Basic usage: ``` pub fn closure_math<F: Fn() -> i32>(op: F) -> i32 { op() } let a = 2; let b = 3; assert_eq!(closure_math(|| a + b), 5);

# 闭包 Base usage: 将计数函数改为闭包形式（Rust 2015） ```rust fn counter(i: i32) -> Box<Fn(i32) -> i32> { Box::new(move |n: i32| n + i ) } fn main() { let f = cou

# 结构体: 面向对象示例 Base usage: 让终端的输出带上颜色 color.rs ```rust use std::fmt; struct ColoredString { input: String, fgcolor: String, bgcolor: String, } impl

# 动态大小类型：比较`&[u32; 5]`和`&mut [u32]`的空间占用 Base usage: ``` fn compare_size(){ assert_eq!(std::mem::size_of::<&[u32; 5]>(), 8); assert_eq!(std::mem::si

# 使用Unsafe进行安全抽象 安全抽象的时候需要注意什么？ --- Basic usage: Vec<T>的insert方法源码示意 正因为存在下面那两个判断条件，才保证了该方法的安全性 ```rust pub fn insert(&mut self, index: usize, e

# 智能指针和所有权: Cow写时复制 是一个枚举类型的智能指针，包括两个可选值：Borrowed，用于包裹引用，以及Owned，用于包裹所有者 一般用于读多写少的场景 Base usage: Cow ```rust use std::borrow::Cow; fn abs_all(input:

# Crossbeam使用 Basic usage: 使用标准库，出错 ```rust let array = [1, 2, 3]; let mut guards = vec![]; // 这样也可以 for &i in &array { for i in &array { let guard

# 自定义闭包实现 Base usage: ```rust #![feature(unboxed_closures, fn_traits)] struct Closure { env_var: u32, } impl FnOnce<()> for Closure { type Output =

# 宏系统: 声明宏 Basic usage: ```rust macro_rules! unless { ($arg:expr, $branch:expr) => ( if !$arg { $branch };); } fn cmp(a: i32, b: i32) { unless!( a >

# 解引用操作将获得所有权 Base usage: 解引用移动语义类型需要注意 ```rust fn join(s: &String) -> String { let append = *s; "Hello".to_string() + &append } fn main(){ let x =

# 设计模式 Base usage: 建造者模式 Rust常用设计模式之一，标准库中std::process::Command就是典型 ```rust struct Circle { x: f64, y: f64, radius: f64, } struct CircleBuilder { x

# Drop检查 使用不当的话，Drop检查会引起UB Basic usage: 声明元组变量测试dropck 在Safe Rust中由dropck引起的问题，借用检查会安全识别，从而引起错误阻止程序编译 ```rust use std::fmt; #[derive(Copy, Clone

# RAII： 确定性析构 Base usage: 实现Drop ``` use std::ops::Drop; #[derive(Debug)] struct S(i32); impl Drop for S { fn drop(&mut self) { println!("drop {}", s

# 结构体: 析构顺序 Base usage: 本地变量 ```rust struct PrintDrop(&'static str); impl Drop for PrintDrop { fn drop(&mut self) { println!("Dropping {}", self.0)

# 消除失败 1. 利用类型系统 2. 利用断言 Base usage: 利用类型系统消除程序中的失败 ```rust fn sum(a: i32, b: i32) -> i32 { a + b } fn main() { sum(1u32, 2u32); // 违反契约，报错 } ```

# 分层错误处理 1. Option 2. Error 3. Panic 4. Abort Base usage: 使用Option<T> ```rust fn get_shortest(names: Vec<&str>) -> Option<&str> { if names.len() >

计算罗马数字，转换为阿拉伯数字

# 函数定义 Basic usage: ``` pub fn fizz_buzz(num: i32) -> String { if num % 15 == 0 { return "fizzbuzz".to_string(); } else if num % 3 == 0 { return "fi

# 零成本抽象 fly_dyn ``` struct Duck; struct Pig; trait Fly { fn fly(&self) -> bool; } impl Fly for Duck { fn fly(&self) -> bool { return true; } } impl

# 零成本抽象 fly_static ``` struct Duck; struct Pig; trait Fly { fn fly(&self) -> bool; } impl Fly for Duck { fn fly(&self) -> bool { return true; } } i

# 泛型 Base usage: 自定义泛型函数 ``` fn foo<T>(x: T) -> T { return x; } assert_eq!(foo(1), 1); assert_eq!(foo("hello"), "hello"); ``` Base usage: 自定义泛型结构体

# for表达式 Basic usage: ``` fn for_fizzbuzz() { for n in 1..101 { if n % 15 == 0 { println!("fizzbuzz"); } else if n % 3 == 0 { println!("fizz"); } el

# 使用`std::mem::forget`跳过Drop Basic usage: 转移结构体中字段所有权 - V1 ```rust struct A; struct B; struct Foo { a: A, b: B } impl Foo { fn take(self) -> (A, B

# 类型转换：as 操作符 Base usage: 无歧义完全限定语法（Fully Qualified Syntax for Disambiguation） 曾用名： 通用函数调用语法（UFCS） ``` struct S(i32); trait A { fn test(&self, i: i32