chore & feat commit rust learn by books

Author: laqudee

.gitignore

@@ -0,0 +1,3 @@
+
+target
+dist

README.md

@@ -0,0 +1,59 @@
+# Rust Learn
+
+- Rust官网【Rust程序设计语言】随书笔记与代码
+
+- [参考地址](https://kaisery.github.io/trpl-zh-cn/ch19-03-advanced-traits.html)
+
+## 简略
+
+- 命令行工具
+- 网络服务器
+- 网页应用
+- 嵌入式开发
+- 等
+
+- rust编译器很重要
+
+- cargo
+- rustfmt
+- rust language server
+
+- 操作系统开发、命令行工具、网络服务、DevOps工具、嵌入式设备、音视频分析与转码、加密货币、生物信息学、搜索引擎、IOT、ML等
+
+- 零开销抽象
+  - 将高级语言特性编译为底层代码，并且与手写的代码运行速度同样快
+
+- 安全、高效、速度、易读易用兼得
+
+- 概念章节
+- 项目章节
+
+- 所有权ownership
+
+- struct, enum, match, if let, module, vector, string, hash map
+- 私有性与公开api
+- 错误处理技术和理念
+- 泛型generic、Trait、lifetime
+- grep
+- closure闭包，iterator， 函数式编程
+- 并发编程模型，thread
+- 模式和模式匹配
+- unsafe rust
+- macro 类型，函数与闭包
+
+- 预编译静态类型ahead-of-time compiled
+
+- cargo是rust的构建系统和包管理器
+
+- 依赖dependencies
+
+- cargo new project_name
+- cargo build，构建项目
+- cargo run ，构建并运行项目
+- cargo check，在不生成二级文件的情况下构建项目来检查错误
+- cargo release
+- cargo update
+
+## Rust WebService
+
+## Rust Yew

a_rust_note/advanced_features/advanced_functions_and_closures.md

@@ -0,0 +1,58 @@
+# 高级函数和闭包
+
+- 函数指针以及返回值闭包
+
+- 函数指针
+  - 通过函数指针允许我们使用函数作为另一个函数的参数
+  - 函数的类型是fn，以免和Fn闭包trait相混淆
+  - fn被称为函数指针
+  - 指定参数为函数指针的语法类似于闭包
+
+```rs
+fn add_one(x: i32) -> i32 {
+    x + 1
+}
+
+fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
+    f(arg) + f(arg)
+}
+
+fn main() {
+    let answer = do_twice(add_one, 5);
+
+    println!("The answer is : {}", answer);
+}
+```
+
+- 不同于闭包，fn是一个类型而不是trait，所以直接指定fn作为参数而不是2声明一个带有Fn作为trait bound的泛型参数
+
+- 函数指针实现了所有三个闭包trait（Fn、FnMut、FnOnce），所以总是可以在调用期望闭包的函数时传递函数指针作为参数
+
+- 倾向于编写使用泛型和闭包 trait 的函数，这样它就能接受函数或闭包作为参数
+
+- 一个只期望接受 fn 而不接受闭包的情况的例子是与不存在闭包的外部代码交互时：C 语言的函数可以接受函数作为参数，但 C 语言没有闭包
+
+- 完全限定语法
+
+- 另一个实用的模式暴露了元组结构体和元组结构体枚举成员的实现细节
+
+```rs
+enum Status {
+    Value(u32),
+    Stop,
+}
+
+let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect();
+```
+
+- 返回闭包
+  - 闭包表现为trait，这意味着不能直接返回闭包
+  - 对于大部分需要返回trait的情况，可以使用实现了期望返回的trait的具体类型来替代函数的返回值会
+
+```rs
+// error
+
+fn returns_closure() -> Box<dyn Fn(i32) -> i32> {
+    Box::new(|x| x+1)
+}
+```

a_rust_note/advanced_features/advanced_traits.md

@@ -0,0 +1,6 @@
+# 高级trait
+
+## 关联类型在trait定义中指定占位符类型
+
+- 关联类型是一个将类型占位符与trait相关联的方式
+

a_rust_note/advanced_features/advanced_types.md

@@ -0,0 +1,149 @@
+# 高级类型
+
+- newtype与类型一样有用
+
+- 类型别名
+
+- `!`类型
+
+- 动态大小类型
+
+## 为了类型安全和抽象而使用newtype模式
+
+- 静态的确保某值不被混淆，和用来表示一个值的单元
+
+- 抽象掉一些类型的实现细节，例如封装类型可以暴露出与直接使用其内部私有类型时所不同的公有API，以便于限制其功能
+
+- newtype还可以隐藏内部的泛型类型
+
+- newtype模式是一种隐藏实现细节的封装的轻量级方法
+
+## 类型别名用来创建类型同义词
+
+- 类型别名，使用type关键字来给予现有类型另一个名字
+```rs
+type Kilometers = i32;
+
+let x: i32 = 5;
+let y: Kilometers = 5;
+
+println!("x + y = {}", x + y);
+```
+
+- 类型别名的主要用途是减少重复
+
+```rs
+Box<dyn Fn() + Send + 'static>
+
+type Thunk = Box<dyn Fn() + Send + 'static>
+
+let f: Thunk = Box::new(|| println!("hi"));
+
+fn takes_long_type(f: Thunk) {
+
+}
+
+fn returns_loong_type() -> Thunk {
+
+}
+```
+
+- 类型别名也经常与`Result<T, E>`结合用来减少重复
+
+```rs
+use std::fmt;
+use std::io::Error;
+
+type Result<T> = std::result::Result<T, std::io::Error>;
+
+pub trait Write {
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+    fn flush(&mut self) -> Result<()>;
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
+}
+```
+
+## 从不返回的never type
+
+- `!`类型，empty type，没有值，或者称之为never type
+  - 作用：在函数从不返回的时候充当返回值
+
+```rs
+fn bar() -> ! {
+
+}
+```
+
+- 从不返回的函数被称为发散函数
+
+- 描述!的行为的正式方式是never type可以强转为任何其他类型
+
+- 允许match的分支以continue结束是因为continue并不真正返回一个值；相反它把控制权交回上层循环，所以在Err的情况，事实上并未对guess赋值
+
+- never type的另一个用途就是panic!
+
+- panic! 是 ! 类型，所以整个 match 表达式的结果是 T 类型
+
+- loop也有!类型
+
+```rs
+impl<T> Option<T> {
+    pub fn unwrap(self) -> T {
+        match self {
+            Some(val) => val,
+            None => panic!("called `Option::unwrap()` on a `None` value"),
+        }
+    }
+}
+
+print!("forever")
+loop {
+    print!(and ever)
+}
+```
+
+## 动态大小类型和Sized trait
+
+- DST或unsized types
+
+- str是一个DST
+
+```rs
+// error
+let s1: str = "Hello there!";
+let s2: str = "How's it going?"
+```
+
+- &str有两个值：str的地址和其长度
+
+- 动态大小类型的黄金法则：必须将动态大小类型的值置于某种指针之后
+
+- sized trait
+
+- rust隐式的为每一个泛型函数增加了Sized bound
+
+```rs
+fn generic<T>(t: T) {
+
+}
+
+// 实际上
+fn generic<T: Sized>(t: T) {
+
+}
+```
+
+- 泛型函数默认只能用于编译时已知大小的类型
+  
+```rs
+fn generic<T: ?sized>(t: &T) {
+
+}
+```
+
+- ?Sized上的trait bound意味着T可能是也可能不是sized 同时这个注解会覆盖泛型类型必须在编译时拥有固定大小的默认规则。
+- 这种意义的 ?Trait 语法只能用于 Sized ，而不能用于任何其他 trait。
+
+- 另外注意我们将 t 参数的类型从 T 变为了 &T：因为其类型可能不是 Sized 的，所以需要将其置于某种指针之后。在这个例子中选择了引用。

a_rust_note/advanced_features/macros.md

@@ -0,0 +1,47 @@
+# 宏
+
+- 什么是宏？
+- 宏怎么工作？
+
+- 宏Macro指的是Rust中一系列的功能：使用macro_rules!的声明宏，和三种过程宏
+    - 自定义`#[derive]`宏在结构体和枚举上指定通过dervie属性添加的代码
+    - 类属性宏定义可用于任意项的2自定义属性
+    - 类函数宏看起来像函数不过作用于参数传递的token
+
+## 宏和函数的区别
+- 从根本上来说，宏是一种为写其他代码而写代码的方式，即所谓的元编程
+
+- 元编程对于减少大量编程和维护的代码是非常有用的，它也扮演了函数扮演的角色。但宏有函数所没有的附加功能
+
+- 实现宏不如实现函数的一面是宏定义要比函数定义更复杂，因为你正在编写生成 Rust 代码的 Rust 代码。由于这样的间接性，宏定义通常要比函数定义更难阅读、理解以及维护
+
+- 宏和函数的最后一个重要区别是：在一个文件里调用宏之前必须定义它或将其引入作用域，而函数则可以在任何地方定义和调用
+
+## 使用macro_rules!的声明宏用于通用元编程
+
+- 声明宏允许我们编写一些类似Rust match 表达式的代码
+
+- `#[macro_export]`，注解表明只要导入了定义这个宏的crate，该宏就应该是可用的。
+
+- `macro_rules!`，用来定义宏
+
+- 分支模式`( $( $x:expr ),* )`
+
+- 宏模式匹配的是Rust代码结构而不是值
+
+- macro 关键字
+
+## 用于从属性生成代码的过程宏
+- 更像函数，接收Rust代码作为输入，产生另一些代码作为输出
+
+- 三种过程宏：
+  - 自定义派生derive
+  - 类属性
+  - 类函数
+
+## 如何编写自定义derive宏
+
+
+## 类属性宏
+
+## 类函数宏