rust learn

1.1.1. std::fmt:

1. format! 的使用 方法： positional params：， named params： ， formating params：
   
2. 示例
   

   format!("Hello, {}!", "world");   // => "Hello, world!"
   format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
   format!("{argument}", argument = "test");
   println!("Hello {:1$}!", "x", 5);
   

3. formating trait: 实践显式 对于外部的Type {}确实需要impl Display， 而{:?} 需要 impl Debug
   
   1. {} => Display
      
   2. {:?} => Debug
      
   3. {:o} => Octal
      
   4. {:p} => Pointer
      
4. fmt::Display vs fmt::Debug
   
   1. Display: 断言 实现者 总是返回 UTF-8 的字符串， 并非所有的 都实现了 Display
      
   2. Debug： 应该为所有pub type 实现， 输出为 内部状态， 该Trait 的目的是为了方便Rust Debug， 可以 使用#[derive(Debug)] 来使用默认的内部实现
      

1.1.2. array & Slice

1. array的类型为： [T: len], let mut array: [i32; 3] = [0; 3];
   
2. Slice: [T]
   

1.1.3. structures： 有三种类型： 1） Tuple struct, 2) classic struct 3) Unit structs

1. struct Pair(i32, f32);
   
2. struct Person { name: String, age: u8}
   
3. struct Unit; unit Struct 没有任何的 field
   

1.1.4. Enums： 包含多个 变体 的 组合项， 任何一个变体 都是一个 正确的 enum 类型

enum WebEvent {
    // An `enum` may either be `unit-like`,
    PageLoad,
    PageUnload,
    // like tuple structs,
    KeyPress(char),
    Paste(String),
    // or c-like structures.
    Click { x: i64, y: i64 },
}

// A function which takes a `WebEvent` enum as an argument and
// returns nothing.
fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("page loaded"),
        WebEvent::PageUnload => println!("page unloaded"),
        // Destructure `c` from inside the `enum`.
        WebEvent::KeyPress(c) => println!("pressed '{}'.", c),
        WebEvent::Paste(s) => println!("pasted \"{}\".", s),
        // Destructure `Click` into `x` and `y`.
        WebEvent::Click { x, y } => {
            println!("clicked at x={}, y={}.", x, y);
        },
    }
}

1.1.5. Type Alias：type 关键字能够 使用 type Name = ExistingType； 语法来 使用 Name 代替 ExistingType 使用。 Self 是一种Type Alias

1.1.6. const， static

1.1.7. Variable Bindings： 1）变量默认 是不可修改的， 使用mut 改变 2） 可以在内部的scope中 其同样的名字来shadow 外部的变量 3）可以使用 先声明 后设定数值的形式 使用变量，但是rust 会检查 使用 未定义变量的错误， 来预防因此产生的问题

1.1.8. Types: 1）转换 as关键字 2） type alias： type NanoSecond = u64; 3） 数值的类型，可以添加到 后面最为后缀使用， 例如： 42i32

1.1.9. Conversion： rust 的struct 以及 enum 等自定义类型的 type转换

1. From & Into:
   
   1. From 为一个类型定义， 如何create self 从 另一个type中转变
      
   2. Into 则是From 的 调用者， From<T> for U 自动实现了 Into<U> for T， blank implement
      
2. TryFrom & TryInto: 类似于 From & Into 不同的是， 转换可能失败，返回Result
   
3. ToString & FromStr:
   
   1. ToString： 单独为 String 类型 定义了一个 ToString Trait，但是并不需要直接实现 ToString，而是实现了 fmt::Display 之后 就自动了提供了 ToString 中的to_string 方法
      

              #[stable(feature = "rust1", since = "1.0.0")]
      impl<T: fmt::Display + ?Sized> ToString for T {
          // A common guideline is to not inline generic functions. However,
          // removing `#[inline]` from this method causes non-negligible regressions.
          // See <https://github.com/rust-lang/rust/pull/74852>, the last attempt
          // to try to remove it.
          #[inline]
          default fn to_string(&self) -> String {
              use fmt::Write;
              let mut buf = String::new();
              buf.write_fmt(format_args!("{}", self))
                  .expect("a Display implementation returned an error unexpectedly");
              buf
          }
      }
      

   2. FromStr & parse: 将String 转换为其他类型， 只需要实现了 FromStr for struct, 而String 中的parse 方法 只是 对FromStr::from_str(&string) 的调用
      
   3. 
      

1.1.10. Expression： 程序是由一系列表达式组成的， 1） 赋值表达式 用; 结尾， 2） {} 也是表达式， 如果最后一个表达式 以; 结尾，则返回 (), 否则为最后一个表达式的 结果

1.1.11. Flow of control：

1. if-else 也是表达式， 所有的分支必须返回同样的类型
   
2. loop： loop break continue。 break 用来随时中断退出loop， continue 则用于 用于 跳过剩下的 代码，重新开始一个 循环
   
   1. loop 是可以嵌套的，并起名字, break ，以及continue 可以使用名字来进行 break， 或者continue
      

      #![allow(unreachable_code)]
      
      fn main() {
          'outer: loop {
              println!("Entered the outer loop");
      
              'inner: loop {
                  println!("Entered the inner loop");
      
                  // This would break only the inner loop
                  //break;
      
                  // This breaks the outer loop
                  break 'outer;
              }
      
              println!("This point will never be reached");
          }
      
          println!("Exited the outer loop");
      }
      
      fn main() {
          let mut counter = 0;
      
          let result = loop {
              counter += 1;
      
              if counter == 10 {
                  break counter * 2;
              }
          };
      
          assert_eq!(result, 20);
      }
      
      

   2. loop 也是可以 返回数值的， 放到break 后面
      
3. while
   
4. for: for in 结构用来 遍历 所有实现了 IntoIterator 的对象， 比如简单 range形式： a..b, a..=b
   
   1. for loop 会自动调用 into_iter 在参数上，我们可以主动产生下面几类实现IntoIterator 的 Iterator：
      
      1. iter: 产生 引用的 Iterator, 对 ownership不产生影响
         
      2. into_iter: 将ownership 交给 Iterator， 调用过之后的对象，将不再可用。产生
         
      3. iter_mut: 产生mut 引用的Iterator， 可以进行修改
         
5. match:
   
   1. c like 方式： 即 match number
      
   2. 解构对象：
      
      1. Tuples： 使用.. 来 忽略剩余所有的 tuple
         
      2. Enums:
         
      3. Pointers: * & ref ref mut 见下面示例
         
      4. Structs: struct 同样可以被match
         
   3. Guards: 在match 对象的arm中，同样可以 使用 if 条件判断 即是 guards
      
   4. Bindings： match 在 arm中，除了解构对象的同时 可以将变量整体绑定 到一个变量上
      

      fn main() {
          let triple = (0, -2, 3);
          // TODO ^ Try different values for `triple`
      
          println!("Tell me about {:?}", triple);
          // Match can be used to destructure a tuple
          match triple {
              // Destructure the second and third elements
              (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z),
              (1, ..)  => println!("First is `1` and the rest doesn't matter"),
              // `..` can be the used ignore the rest of the tuple
              _      => println!("It doesn't matter what they are"),
              // `_` means don't bind the value to a variable
          }
      }
      
      //point s 
      
      fn main() {
          // Assign a reference of type `i32`. The `&` signifies there
          // is a reference being assigned.
          let reference = &4;
      
          match reference {
              // If `reference` is pattern matched against `&val`, it results
              // in a comparison like:
              // `&i32`
              // `&val`
              // ^ We see that if the matching `&`s are dropped, then the `i32`
              // should be assigned to `val`.
              &val => println!("Got a value via destructuring: {:?}", val),
          }
      
          // To avoid the `&`, you dereference before matching.
          match *reference {
              val => println!("Got a value via dereferencing: {:?}", val),
          }
      
          // What if you don't start with a reference? `reference` was a `&`
          // because the right side was already a reference. This is not
          // a reference because the right side is not one.
          let _not_a_reference = 3;
      
          // Rust provides `ref` for exactly this purpose. It modifies the
          // assignment so that a reference is created for the element; this
          // reference is assigned.
          let ref _is_a_reference = 3;
      
          // Accordingly, by defining 2 values without references, references
          // can be retrieved via `ref` and `ref mut`.
          let value = 5;
          let mut mut_value = 6;
      
          // Use `ref` keyword to create a reference.
          match value {
              ref r => println!("Got a reference to a value: {:?}", r),
          }
      
          // Use `ref mut` similarly.
          match mut_value {
              ref mut m => {
                  // Got a reference. Gotta dereference it before we can
                  // add anything to it.
                  *m += 10;
                  println!("We added 10. `mut_value`: {:?}", m);
              },
          }
      }
      
      fn main() {
          struct Foo {
              x: (u32, u32),
              y: u32,
          }
      
          // Try changing the values in the struct to see what happens
          let foo = Foo { x: (1, 2), y: 3 };
      
          match foo {
              Foo { x: (1, b), y } => println!("First of x is 1, b = {},  y = {} ", b, y),
      
              // you can destructure structs and rename the variables,
              // the order is not important
              Foo { y: 2, x: i } => println!("y is 2, i = {:?}", i),
      
              // and you can also ignore some variables:
              Foo { y, .. } => println!("y = {}, we don't care about x", y),
              // this will give an error: pattern does not mention field `x`
              //Foo { y } => println!("y = {}", y),
          }
      }
      
      
      fn main() {
          let pair = (2, -2);
          // TODO ^ Try different values for `pair`
      
          println!("Tell me about {:?}", pair);
          match pair {
              (x, y) if x == y => println!("These are twins"),
              // The ^ `if condition` part is a guard
              (x, y) if x + y == 0 => println!("Antimatter, kaboom!"),
              (x, _) if x % 2 == 1 => println!("The first one is odd"),
              _ => println!("No correlation..."),
          }
      }
      
      
      // A function `age` which returns a `u32`.
      fn age() -> u32 {
          15
      }
      
      fn main() {
          println!("Tell me what type of person you are");
      
          match age() {
              0             => println!("I haven't celebrated my first birthday yet"),
              // Could `match` 1 ..= 12 directly but then what age
              // would the child be? Instead, bind to `n` for the
              // sequence of 1 ..= 12. Now the age can be reported.
              n @ 1  ..= 12 => println!("I'm a child of age {:?}", n),
              n @ 13 ..= 19 => println!("I'm a teen of age {:?}", n),
              // Nothing bound. Return the result.
              n             => println!("I'm an old person of age {:?}", n),
          }
      }
      
      

6. if let: 在判断的同时 进行match
   
7. while let
   

1.1.12. Functions:

1. methods: 依附于 对象的函数， 在methods 的block中，能够 通过self使用 对象的 数据
   
2. closures: |val| {val + x}
   
   1. Capturing： 捕获， 其可以 捕获环境中的 变量， 可以是： &T, &mut T , T（by value）
      
   2. 作为参数： 分为三类： Fn, FnMut, FnOnce， 对应ownership 的 &T, &mut T, T. Fn 可以无限次执行， FnMut 则要求 capture 变量的 mut 引用， FnOnce 则 只能执行一次
      
      1. 疑问：
         
         1. 1. 如何 区分 Fn(i64, i64) -> i64 与Fn(&String) -> i64
            
         2. 2. FnOnce 是如何确定的， 有些函数，即便将变量 move 到了block中， 然而依然可以调用多次， 这些优势如何判断的？ 根据内部函数调用的 Fn 属性吗？ 比如mem::drop(p) 则 包含其调用的函数 则为 FnOnce?
            
         3. 3. 如何断定 Cloosure 为 Fn or FnMut ?
            

            struct Point {
                x: f64,
                y: f64,
            }
            
            // Implementation block, all `Point` methods go in here
            impl Point {
                // This is a static method
                // Static methods don't need to be called by an instance
                // These methods are generally used as constructors
                fn origin() -> Point {
                    Point { x: 0.0, y: 0.0 }
                }
            
                // Another static method, taking two arguments:
                fn new(x: f64, y: f64) -> Point {
                    Point { x: x, y: y }
                }
            }
            

1.1.13. Modules:

1. mod visibility: mod 的可见性， mod 默认只能在本mod 可见， 需要使用 pub 来对外可见， 定义其中的fn， struct 使用同样的规则， 因为mod 可以nest， 所以 存在pub(self) (等同于private) pub(super) 即让super mod 可见, 而pub(crate)则让crate 可见
   
2. struct visibility: struct 中包含fn 以及 field，默认都为 对 所在 定义的mod可见， pub 则开放为对外部的 mod可见
   
3. mod vs struct: struct 的控制比较弱， mod的控制则相对复杂， struct 可能并不需要如此复杂的规则吧
   
4. 关键字 use： 我们可以使用 use mod::struct as another_struct 来 减少路径的拼写， 使用as 更可以 启用别名
   
5. mod 的 使用类似于 Unix下的 目录 安排， super 代表 .. self 则代表 本mod
   

1.1.14. Attributes: 可以用来作什么？ 1） 条件编译， 2）设定crate 属性， 3）关闭 warning 4)启用编译器特性(maros etc) 5） link to a foreign library 6) 设定unit test

1. 形式： 当应用到 整个crate： #![crate_attribute], 应用到module 或者 item ： #[item_attribute]
   
2. 还可以接受参数： 1) #[attribute = "value"] 2) #[attribute(key = "value")] 3) #[attribute(value)]
   
3. 示例：
   
   1. #[allow(dead_code)]： 关闭rust 关于没有调用函数的提示
      
   2. #![crate_name = "rary"]
      
   3. cfg(Configuration): 1） #[cfg(…)] 条件编译 2） cfg!(…) 在运行阶段的条件判断， 返回bool值
      

      // This function only gets compiled if the target OS is linux
      #[cfg(target_os = "linux")]
      fn are_you_on_linux() {
          println!("You are running linux!");
      }
      
      // And this function only gets compiled if the target OS is *not* linux
      #[cfg(not(target_os = "linux"))]
      fn are_you_on_linux() {
          println!("You are *not* running linux!");
      }
      
      fn main() {
          are_you_on_linux();
      
          println!("Are you sure?");
          if cfg!(target_os = "linux") {
              println!("Yes. It's definitely linux!");
          } else {
              println!("Yes. It's definitely *not* linux!");
          }
      }
      

4. 
   

1.1.15. Smart Pointer:

1. Box: heap store
   
2. Rc<T>: Reference Counter
   
   1. Rc::clone(&rc) || rc.clone()
      
   2. Rc::strong_count
      
   3. Rc::weak_count
      

1.1.16. OIBITs:

1.1.17. stand for “opt-in builtin trait”: 比如 Send， Sync， 该种 Trait 默认 为所有的 struct enum 提供默认实现， 即： 如果 struct A 中的field 都impl Trait 则 struct A 也同样 impl Trait。

1.1.18. 参考链接, 参考链接1

1.1.19. impl Trait: 目前 可以在 fn xxx() -> impl Trait

1.1.20. Box<Trait> vs Box<T> where T: Trait vs &Trait 的区别：

1.1.21. dyn trait:

1.1.22. rust stackoverflow 问题： 使用 lldb target/debug/deps/smoke-910c8a3208aec5c7 ，跟gdb 调试一样，定义定位到 callstack的相关信息

1.4.1. rustup: rust complier 的管理工具， 可以方便的切换 stable, beta, and nightly

1.4.2. cargo: 是rust的包管理工具， 用来 下载 rust的依赖， 编译， 以及 分发 到 crates.io

1. 在安装 rust 之后， cargo 也会被自动安装上，
   
2. cargo 提供了一些有用的工具有:
   
   1. cargo new package # default –bin 生成 可执行 program, 可以pass –lib 来产生库程序
      
   2. cargo build
      
   3. cargo 存在的意义：
      
      1. 剥离 rustc 的复杂度， 类似 make 与 c 一样
         
      2. cargo 最终调用rustc 来编译 项目， 当然可以 直接使用 rustc 来编译项目，但是 需要出入 复杂的参数 来 添加项目 依赖关系， 编译文件， 依赖关系 等，并精心安排顺序 来进行调用。
         
      3. 所以使用cargo： make工具， cargo 的功能
         
         1. 1. 使用两个文件 来 包含 package的信息
            
         2. 2. 拉取，构建 package 依赖
            
         3. 3. 使用正确的参数 来调用rustc 或者其他 tool， 来构建项目
            
         4. 4. 引用约定，方便package 构建
            
      4. cargo 使用笔记：
         
         1. cargo new hello_world –bin
            
            1. 
               

               $ cd hello_world
               $ tree .
               .
               ├── Cargo.toml
               └── src
                   └── main.rs
               
               1 directory, 2 files
               

         2. 其中 Cargo.toml 被称为 manifest,包含package的元数据
            
            1. 
               

               fn main() {
                   println!("Hello, world!");
               }
               
               
               $ cargo build
                  Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)
               
               $ ./target/debug/hello_world
               Hello, world!
               
               
               $ cargo run
                  Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)
                    Running `target/debug/hello_world`
               Hello, world!
               
               
               
               $ cargo build --release
                  Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)
               
               

         3. cargo build 将会 构建 package
            
         4. cargo run 则 构建并运行它
            
         5. cargo build –release 将 构建 优化的代码
            
         6. cargo 默认的构建 代码优化级别 为 debug, 存在的目录为 target/debug, 构建 优化后的代码需要 显式传递 参数 –release 生成的文件目录为 target/release
            
         7. Dependencies：
            
            1. crate.io 为 rust 中间的 package 机构， 用于发现 下载 更新package
               
            2. 添加依赖关系： 在 Cargo.toml 中 的dependencies 下，添加项目
               
               1. 
                  

                  [package]
                  name = "hello_world"
                  version = "0.1.0"
                  authors = ["Your Name <you@example.com>"]
                  edition = "2018"
                  
                  [dependencies]
                  time = "0.1.12"
                  regex = "0.1.41"
                  

         8. 之后的 cargo build 过程
            
            1. 
               

               $ cargo build
                     Updating crates.io index
                  Downloading memchr v0.1.5
                  Downloading libc v0.1.10
                  Downloading regex-syntax v0.2.1
                  Downloading memchr v0.1.5
                  Downloading aho-corasick v0.3.0
                  Downloading regex v0.1.41
                    Compiling memchr v0.1.5
                    Compiling libc v0.1.10
                    Compiling regex-syntax v0.2.1
                    Compiling memchr v0.1.5
                    Compiling aho-corasick v0.3.0
                    Compiling regex v0.1.41
                    Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)
               

         9. package 构成：
            
            1. 
               

               .
               ├── Cargo.lock
               ├── Cargo.toml
               ├── src/
               │   ├── lib.rs
               │   ├── main.rs
               │   └── bin/
               │       ├── named-executable.rs
               │       ├── another-executable.rs
               │       └── multi-file-executable/
               │           ├── main.rs
               │           └── some_module.rs
               ├── benches/
               │   ├── large-input.rs
               │   └── multi-file-bench/
               │       ├── main.rs
               │       └── bench_module.rs
               ├── examples/
               │   ├── simple.rs
               │   └── multi-file-example/
               │       ├── main.rs
               │       └── ex_module.rs
               └── tests/
                   ├── some-integration-tests.rs
                   └── multi-file-test/
                       ├── main.rs
                       └── test_module.rs
               

            2. Cargo.toml and Cargo.lock 在项目的根目录
               
            3. src 下 为源代码
               
            4. 默认的 library file 为 src/lib.rs
               
            5. 默认的 executable file 是 src/main.rc, 其他的 放在 src/bin/
               
            6. 基准测试 放在benches 目录下
               
            7. 示例代码放在examples 目录下
               
            8. 集成测试 放在 tests 目录下
               
            9. 其他详细的需要参看 https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html
               
            10. 
                
         10. Cargo.toml 与 Cargo.lock: 两种目的，
             
             1. cargo.toml 描述 大概的依赖关系 并不准确，是由 人来确定的
                
             2. Cargo.lock 包含准确的依赖关系， 由cargo 来维护
                
             3. https://doc.rust-lang.org/cargo/faq.html#why-do-binaries-have-cargolock-in-version-control-but-not-libraries
                
         11. 示例:
             
             1. 
                

                Cargo.toml
                
                [package]
                name = "hello_world"
                version = "0.1.0"
                authors = ["Your Name <you@example.com>"]
                
                [dependencies]
                rand = { git = "https://github.com/rust-lang-nursery/rand.git", rev = "9f35b8e" }
                
                
                Cargo.lock
                
                
                [[package]]
                name = "hello_world"
                version = "0.1.0"
                dependencies = [
                 "rand 0.1.0 (git+https://github.com/rust-lang-nursery/rand.git#9f35b8e439eeedd60b9414c58f389bdc6a3284f9)",
                ]
                
                [[package]]
                name = "rand"
                version = "0.1.0"
                source = "git+https://github.com/rust-lang-nursery/rand.git#9f35b8e439eeedd60b9414c58f389bdc6a3284f9"
                

         12. Cargo.lock 中包含 依赖的确定的 version， 当其他人使用的时候， 他们将使用相同的 sha，即便我们并没有在Cargo.toml 中使用
             
         13. cargo update 更新全部的依赖， cargo update -p rand 只更新依赖 rand
             
         14. Test:
             
             1. cargo test 执行 package中的所有test， test主要有两种： 1) 在每个 src 目录中的文件， 2） tests/ 目录下的所有文件。 1）中的为单元测试， 2）则为 集成测试，
                
             2. 
                

                $ cargo test
                   Compiling rand v0.1.0 (https://github.com/rust-lang-nursery/rand.git#9f35b8e)
                   Compiling hello_world v0.1.0 (file:///path/to/package/hello_world)
                     Running target/test/hello_world-9c2b65bbb79eabce
                
                running 0 tests
                
                test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
                

             3. cargo test foo 可以单独执行 名字为foo的测试，
                
             4. cargo test 其实还会执行 额外的测试，包含在 src中的部分 文档中的测试（并不重要，为补充部分）
                
             5. Cargo Home： 当build package的时候， cargo 将下载的依赖package 存储到 Cargo home 下。当做cache 使用。
                
             6. 可以通过 改变 环境变量 CARGO_HOME 来改变 cargo home的值， 默认 为 $HOME/.cargo/
                
             7. Cargo Home 目录下的 数据：
                
                1. bin 目录： 可执行crate， 包括cargo install 或者 rustup 安装的
                   
                2. git/db: crate 依赖git 项目时， cargo clone 项目到 该目录下
                   
                3. git/checkouts： git/db 项目中的检出到该文件， 比如 依赖于特定的commit
                   
                4. registry： 项目依赖于 crate.io 中的crate 存放在该目录下
                   
                   1. registry/index： crate 的原数据， 包括： version， dependencies 等
                      
                   2. registry/cache： 下载的crate 储存到该目录下， 存储形式为 .crate 的gzip压缩文件
                      
                   3. registry/src： cache 的解压形式 存放在 该文件中
                      
         15. 指定 Dependencies：
             
             1. 依赖版本： 版本号各个位置数字的含义： SemVer compatible 与 link 中讲的同样， major.minor.patch
                
                1. Caret requirements： 指定 可以使用 一个 major 版本号 不变的更新， 但是 0 是 一个特殊的数字，标识不与 任何 数字兼容。即是： 0.0.1， 与 0.1.x 不兼容
                   
                   1. 下面为兼容样例：
                      
                   2. 
                      

                      ^1.2.3  :=  >=1.2.3, <2.0.0
                      ^1.2    :=  >=1.2.0, <2.0.0
                      ^1      :=  >=1.0.0, <2.0.0
                      ^0.2.3  :=  >=0.2.3, <0.3.0
                      ^0.2    :=  >=0.2.0, <0.3.0
                      ^0.0.3  :=  >=0.0.3, <0.0.4
                      ^0.0    :=  >=0.0.0, <0.1.0
                      ^0      :=  >=0.0.0, <1.0.0
                      

                2. Tilde requirements: 分为以下情况:
                   
                   1. 有 major.minor.patch 或者 major.minor 只有patch version 的升级是允许的
                      
                   2. 有major情况下, minor patch verison的升级 是允许的
                      
                   3. for example
                      
                   4. 
                      

                      ~1.2.3  := >=1.2.3, <1.3.0
                      ~1.2    := >=1.2.0, <1.3.0
                      ~1      := >=1.0.0, <2.0.0
                      

                3. Wildcard requirements:
                   
                   1. 允许所在位置上的 任何版本
                      
                   2. for example
                      
                   3. 
                      

                      \*     := >=0.0.0
                      1.*   := >=1.0.0, <2.0.0
                      1.2.* := >=1.2.0, <1.3.0
                      

                4. Workspaces: workspace 下的一系列package 共享同样的Cargo.lock， output dir， 多样的配置（比如profile）， workspace下的packages 被称为 workspace members
                   
                   1. 存在两种形式： 1） [package] 与 [workspace] 共存在 Cargo.toml 中 2） 只有 [workspace] 存在Cargo.toml 中， 被称作 Virtual manifest
                      
                   2. 主要作用：
                      
                      1. 1. 共享Cargo.lock
                         
                      2. 2. 共享output dir， Cargo.toml 中 [target]
                         
                      3. 3. [patch], [replace] and [profile.*] sections in Cargo.toml 只能在 识别 workspace 中的 manifest，member package 中的被忽略
                         
                   3. workspace section 中的配置
                      
                   4. 
                      

                      [workspace]
                      members = ["member1", "path/to/member2", "crates/*"]
                      exclude = ["crates/foo", "path/to/other"]
                      

                      1. members 为 成员package 列表， exclude 排除 member
                         
                   5. workspace 寻找： Cargo 自动的 向上目录 寻找 含有 [workspace] 的Cargo.toml， 在 member中可以指定 package.workspace 来 直接指定 workspace 的位置， 来防止自动查找， 这个对于 没有在 workspace 目录下的member package 非常有用
                      
                   6. member package： cargo commadn -p package 可以指定 package 来 执行命令， 如果没有指定 package， 则 选择当前所在目录的package， default-members = ["path/to/member2", "path/to/member3/"] 可以指定默认的 操作的member package
                      

1.4.3. rustup： 从官方下载rustc， 使能够随意的在 stable, beta, nightly 中切换。 让 cross-compiling 编译变的简单

1. 工作原理： rustup 通过 ~/.cargo/bin 下的工具 来实现其功能， 比如 安装在~/.cargo/bin 下的 rustc cargo 只是一个 到真正执行工具的 代理，
   
   1. rustup 提供了一个方便的机制来 控制 这些代理的行为， 比如 通过执行rustup default nightly 来切换 nightly 下的工具
      
2. 概念:
   
   1. channel: rustc 按照 beta, night, stable 三个 channel 进行发布， channel 并没有什么用， 只是个概念而已。
      
   2. toolchain： rustc and cargo 等相关工具。 因为能够控制rustc 即是channel概念下的实际应用。
      
   3. target： rustc 可以为多个平台生成代码。 默认的 rustc 使用host 作为target， 为了生成不同target的代码，我们需要 使用rustup target 来安装目标target
      
   4. component: 每个rust版本的发布，都会包含一些 组件， 包括，rustc， clippy 等
      
   5. profile： 为了更好的与component 工作， profile 定义了 一组component，
      
3. toolchain： rustup 不仅可以 安装stable, beta, nightly 三个channel， 还可以安装 其他的 官方 历史版本
   
   1. channel 的命令规则:
      

      <channel>[-<date>][-<host>]
      
      <channel>       = stable|beta|nightly|<major.minor>|<major.minor.patch>
      <date>          = YYYY-MM-DD
      <host>          = <target-triple>
      
      

4. 其他命令： 保持 rust 更新：
   

   $ rustup update
   info: syncing channel updates for 'stable'
   info: downloading component 'rustc'
   info: downloading component 'rust-std'
   info: downloading component 'rust-docs'
   info: downloading component 'cargo'
   info: installing component 'rustc'
   info: installing component 'rust-std'
   info: installing component 'rust-docs'
   info: installing component 'cargo'
   info: checking for self-updates
   info: downloading self-updates
   
     stable updated: rustc 1.7.0 (a5d1e7a59 2016-02-29)
   

5. 如上， rustup update 会更新 stable， component， 以及 rustup self， 可以使用 rustup self update 来手动更新rustup
   

1.5.1. Drop

1. 调用时机： Value drop的时候， 在struct 内部 field drop之前， drop func 内 可以使用 field， struct drop之后，内部的field 的drop func 依次调用
   
2. 何时需要： struct 存在rust 不能够理解的资源时
   

1.5.2. Sized: marker trait , rust 用来标记 在 compile时期， size 能够确定的 type

1. unsized de type 有： str, [T] （变长， 但 &str, &[T] 指针 依然是 Sized）
   
2. unsized 的type 不能够存储变量， 所以不能够作为 function 的 args 使用， 需要 使用 指针引用
   
3. 可以使用 T:Sized, T:?Sized 来限制type 的类型， ?Sized 表示 可以为 unsized type
   

1.5.3. Clone:

fn clone(&self) -> Self;
fn clone_from(&mut slef, source: &Self);  //用 source 变量中的data 来装备自己， 比 clone 要快

1. #[derive(Clone)]
   
2. std::fs::File, sync::mutex 不支持 clone
   

1.5.4. Copy: 基本类型 i32， i64 etc

1. A = B 不是 Ownership的转移 ， 而是 clone B -> A
   
2. Copy: Clone, Clone 是copy的 super trait
   
3. #[derive(Copy, Clone)]
   
4. Clone 为 复制 复杂数据结构，耗时操作 提供 clone 方法 #[derive(Clone)]
   
5. Copy 有一些特殊，除非member 包含简单的数据结构类型，否则不能够实现 Copy
   
6. Copy 只能够 通过标记 #[derive(Copy)] 来实现
   

1.5.5. Deref & DerefMut : rust 自动尝试 插入 deref() 代码，当类型不匹配时， 可以经过多次插入

trait Deref {
  type target: ?Sized;

  fn deref(&self) -> &Self::target;
}

1. 1. 为 Smart Pointer 设计. Box, Rc, Arc
   
2. 2. 模版参数， 不提供代码插入。
   

1.5.6. Default

trait Default {
  fn  default() -> Self;
}

1. String, Collections 都实现了Default;
   
2. #[derive(Default)] 如果 struct 各个field 都实现了 Default
   

1.5.7. AsRef & AsMut:

1. 定义
   

   trait AsRef<T: Sized> { 
       fn as_ref(&self) -> &T;
   }
   

2. 对比 Deref， rust不提供代码插入
   
3. 从 A 中 as_ref B 出来， 扩大参数接受范围
   

   fn open<P: AsRef<Path>> (path: P) -> Result<File> {
      let path: Path = path.as_ref():
      //....
   }
   let fs = std::fs::File::open("xxxxxx.txt");
   

4. 减少 具体的 type 定义， 在写 Trait AsFoo之前 应该尝试 AsRef<Foo>
   

1.5.8. Borrow & BorrowMut

1. 定义：
   

   trait Borrow(Borrowed: ?Sized)    {
       fn borrow(&self)-> &Borrowed:
   }
   
   impl HashMap<K, V> where K: Eq + Hash {
       fn get<Q: ?Sized> (&self, key: &Q) -> Option<&V> {
          where K: Borrow<Q>,
                Q: Eq + Hash
               // ...
        }
   }
   
   

2. 与AsRef 相似， 但是添加了 Hash Trait impl 的限制
   
3. 限制 HashMap<K, V>.get(key: &Q) Q为 HashMap 中的 key 能够 Borrow 出来，不影响 HashMap中的K 的ownership, 从而能够 loopup 到对应的key， 扩大 get(&Q) 的参数范围。
   
4. 比如 HashMap<String, String> 可以 hashmap.get("xx")
   

1.5.9. From & Into:

1. 定义：
   

   trait Into<T: Sized> {
      fn into(&self) -> T;
   }
   

2. 消耗 Type A ownership 返回 type B
   
3. if A imp From<B> 则 rust 自动impl B impl Into<A>
   
4. 使用场景： Into 作为 fun 的args， 使 args 更加灵活， From 作为 构造函数 从多个 类型 -> Self
   
5. 因为 Into 需要消耗 ownership 所以 “重”， 因为可能会产生内存分配
   

1.5.10. ToOwned:

1. 定义：
   

   trait ToOwned {
     type Owned: Borrow<Self>; // 主意该限制
     fn to_owned(&self) -> Self::Owned;
   }
   

2. 解决 clone limit, 因为 &A.clone() -> A, 所以 &str 不能够 impl Clone Trait (因为 无法返回 str: unsized 类型)
   
3. 所以 &str 可以 .to_owned -> String
   

1.5.11. Send, Sync

1. Send: 1. safe pass value between threads 2. move ownership cross threads
   
2. Sync: 1. safe pass none mut ref between threads. 2. share cross threads, only &T is Send, then T is Sync, 所以Sync 与 Send之间必然存在一些联系。
   
3. Send 应该 > Sync
   
4. ? 如果实现 &T Send， 则 T 必须 Sync, 说明 在 不同的thread 之间 Send的时候， 至少 可能跟 Rc 一样，会改变计数，来决定 哪一个Thread会进行释放， 但是 Arc<T> if T impl Sync， 才能 impl Send， 所以T: Sync 到底意味着什么？
   
5. 不需要 #[derive] rust 自动提供 marker
   
6. 但依然可以 手动 impl for Struct，即自由的控制type 是否可以Send， Sync：
   
   1. unsafe impl Send for MyBox {} ;
      
   2. unsafe impl Sync for MyBox {} ;
      
   3. impl !Send for MyBox {};
      
   4. impl !Sync for MyBox {};
      

1.5.12. Ref Pointer:

1. Cell, RefCell: 增加 borrow checker（runtime）
   
   1. 内部可变, 使用场景： 1. 内部可变化，外部不可变 2. Rc.clone(&ref) 方法， ref 不可变，但是内部增加了 引用计数
      
2. Rc: reference counter， smart pointer (管理 Heap Memory)
   

   let rc = Rec::new(data);
   let rc1 = Rc::clone(&rc);
   

3. Arc: atomicaly Reference counter （多线程 版本Rc）
   
   1. 默认 unmut, Arc 需要 配合 Mutex, RwLock, Atomic 使用
      
   2. Arc<T> if T impl Send & Sync 则 Arc<T> impl Send & Sync
      
   3. Arc 永远 thread safe 指的是其中的counter， 但是没有 add thread safe to <T> （内部的data）
      
   4. 例如 Arc<RefCell<T>> 并不是 thread safe Arc 是， 但RefCell 并不是，所以 Arc<RefCell<T> 并不是 thread safe
      
4. Reference Counter（包括 Rc, Arc） 都存在对应的 Weak 类型，已解决环问题: downgrade -> Weak<T> -> upgrade -> Option<Rc<T>>
   

1.6.1. doc 中经常出现 primitive type 与 std:: 的问题， 是因为 primitive type是 compiler 实现的。 而 std 也实现了同样名字的一部分。所以是此现象

1.6.2. rust prelude:

1.6.3. iter module: 是一个 关于 iter 的模块，包含了 一系列的 trait， struct 用于支持 Iterator

1.6.4. Vev Iter, Iterator, Enumerate 函数中 find, map block中的参数类型，是否 为 &T, &mut T

1. 其中 &T 可以 被 x 或者 &x 匹配，&mut T 可以被 x 或者 &mut x 匹配， 如果其中的 T 不能够borrow 出来的话，
   
2. 需要使用 ref x 或者 ref mut x ， 这时候 x 的类型为 && T 或者 &&mut T。ref 的含义为： 设定x为 目标的引用
   
3. 所以并不会如 &x 一样 将 &T 中的T borrow出来。
   
4. 下面的代码可以查看 对应的type_of(&var) 的具体类型。
   

   use std::any::type_name;
   
   fn type_of<T>(_: T) -> &'static str {
       type_name::<T>()
   }
   
   
   // 需要注意，这里面 iter 被find之后，players 被消耗掉了.
   let mut players = player::Player::get_many(&realm_mysql, &ary)?.into_iter();
   println!("players is ---------- {:?}, {:?}, {:?}", players, sender_id, recipient_id);
   let i_data = players.find(|x| x.id == sender_id);
   println!("players is ---------- {:?}", i_data);
   let sender = match i_data {
     Some(data) => data,
     None => return Ok(None),
   };
   
   println!("players is ---------- {:?}", players);
   let i_data = players.find(|x| x.id == recipient_id);
   println!("players is ---------- {:?}", i_data);
   

1.6.5. Box: Box::new(T) 方法

1.6.6. Borrow Trait 的错误使用： 下面为代码的 正确使用示例： 为什么会如此设计？

1. 1. HashMap<K, V> 因为K 能为一个 heap分配的对象，比较 heavy，所以 我们采用 Borrow<Q> for K, 来实现 .get(Q) ， 例如 Borrow<str> for String
   
2. 2. 对于 Hash的 impl， 对于 使用于HashMap的K，实现 Borrow<Q> for K 比较 特殊，需要保证 Q 与 K hash 数值的相同。
   
3. 3. 点 2 在 hash map inner impl 中 有所体现 , 即 HashMap.get(Q) 中 get_inner<Q: ?Sized>(&self, k: &Q) -> Option<&(K, V)> 中 let hash = make_hash::<K, Q, S>(&self.hash_builder, k); 直接 使用了 k: &Q 做了 hash， 所以 &Q 与 K 的hash 必然一致才行
   

   use std::borrow::Borrow;
   use std::collections::HashMap;
   use std::hash::{Hash, Hasher};
   
   #[derive(Debug, Clone, Copy, PartialEq, Eq)]
   pub enum AbType {
       Rss,
       Gold,
   }
   
   impl Borrow<str> for AbType {
       fn borrow(&self) -> &str {
           match self {
               &AbType::Gold => "gold",
               &AbType::Rss => "rss",
           }
       }
   }
   
   impl Hash for AbType {
       fn hash<H: Hasher>(&self, state: &mut H) {
           let s: &str = self.borrow();
           s.hash(state);
       }
   }
   
   fn main() {
       let mut hash = HashMap::new();
       hash.insert(AbType::Gold, 10);
   
       let val = hash.get("gold");
       let gold_val = hash.get(&AbType::Gold);
       println!("val: {:?}, goldVal: {:?}", val, gold_val);
   }
   

1.6.7. FromIterator: 定义如下:

pub trait FromIterator<A>: Sized {
    fn from_iter<T>(iter: T) -> Self
    where
        T: IntoIterator<Item = A>;
}

1. 主要用于 提供 从 Iterator 构建 Self 的一种方法, T 需要 impl IntoIterator<Item>
   
2. 主要实现有: String, HashMap, Vec, 以及 Option<V> , Result<V, E>
   

1.6.8. Vec: 的使用

1.6.9. rust thread unwrap 的问题

1.7.1. Compiler Reordering: 编译器 将分析 程序，并重新排列 指令 以优化 程序性能， example：

  x = 1;
  y = 3;
  x = 2;
//------------
  x = 2;
  y = 3;

1.7.2. Hardware Reordering: 因为cpu的内存层次结构设计， 比如 每个Cpu都存在L1，共用 L2， 同样将导致问题。example：

1.7.3. 不同的 cpu 存在不同的 保证： strongly-ordered(Inter) and weakly-ordered(Arm)

1. 在提供 strongly-ordered 的cpu 上，要求强order，花费非常小， 在weakly-ordered 的cpu上，要求强order， 则代价非常大。
   

1.7.4. C++ 内存模型通过 因果一致 （causality result） 来弥补 cpu/ compiler 之间的差异。

1.7.5. data access：

1. 基础的数据访问是 不同步的， compiler 可以自由的优化，cpu 可以自由的 将 数据更改 传播到 其他线程，
   
2. 关键的是： 数据访问是 竞争（race）发生的重要方式。
   
3. 在没有限制的数据访问 基础之上 是不可能构建出 sync 代码的。
   
4. Atomic 告诉 hardware/compiler 程序是 多线程的。
   
5. 通过 限制 compiler / hardware 不能做的事情， 来实现 正确的数据访问。 分为 限制 compiler 指令重排 , 以及 hardward 如何将变量更改传播到其他 thread
   

1.7.6. rust 的 Ordering: 类型

1. Sequentially Consistent (SeqCst)
   
2. Release
   
3. Acquire
   
4. Relaxed
   

1.7.7. Sequentially Consistent: 最为安全的模式，将限制Compiler 对于指令的重排，Hardware则将更改完全同步到 其他 thread。代价： 即便是 strongly-ordered cpu 依然 可能需要使用 momory fences(内存栅栏) 来实现

1.7.8. Acquire-Release: 非常适合 lock 的 acquire/release, 确保关键部分内容 不会重叠（overlap）

1. Acquire: 保证之后的每个访问 都发生在 之后（compiler 不会重排它之后的指令到 之前， 但是可以 将 它之前的访问指令 重排到 它之后）
   
2. Release: 保证之前的指令 都发生在它之前（compiler 不会重排它 之前的指令到 之后， 但是可以将 它 之后发生的指令 重排 到它之前）
   
3. hardware 保证 对于 相同变量的更改 将由所有 thread 观察到
   

   use std::sync::Arc;
   use std::sync::atomic::{AtomicBool, Ordering};
   use std::thread;
   
   fn main() {
       let lock = Arc::new(AtomicBool::new(false)); // value answers "am I locked?"
   
       // ... distribute lock to threads somehow ...
   
       // Try to acquire the lock by setting it to true
       while lock.compare_and_swap(false, true, Ordering::Acquire) { }
       // broke out of the loop, so we successfully acquired the lock!
   
       // ... scary data accesses ...
   
       // ok we're done, release the lock
       lock.store(false, Ordering::Release);
   }
   
   

4. 使用 Acquire 以及 Release 的组合，能够保证在 范围内的 代码 始终在 acquire/realse 范围包围内。
   

1.7.9. Relaxed： 最弱的atomic order， 但依然是 atomic， read-modify-write 依然是原子操作， 不能够提供 Acquire/Release 提供的保证。对于 weakly-order cpu 非常好用

1.7.10. fense: 栅栏，rust还提供了 fense 操作， 在Arc 的Drop 操作中，使用 来保证 代码顺序的发生

impl<T> Drop for Arc<T> {
    fn drop(&mut self) {
        let inner = unsafe { self.ptr.as_ref() };
        if inner.rc.fetch_sub(1, Ordering::Release) != 1 {
            return;
        }
        // This fence is needed to prevent reordering of the use and deletion
        // of the data.
        atomic::fence(Ordering::Acquire);
        // This is safe as we know we have the last pointer to the `ArcInner`
        // and that its pointer is valid.
        unsafe { Box::from_raw(self.ptr.as_ptr()); }
    }
}

1.8.1. 1. Builder 用来 自定义Thread name, stack_size 参数配置

1.8.2. 2. ::spawn(f) 经过层层调用, 最终为: spawn_unchecked_ 其 内部 组装 main函数, __rust_begin_short_backtrace(f), 并调用 imp::Thread::new(stack_size, Box::new(main)) //可能为 系统native调用

// just build a Thread struct ,no spawn, 其中 包含 Parker Object
let my_thread = Thread::new(name.map(|name| {
    CString::new(name).expect("thread name may not contain interior null bytes")
}));

let main = move || {
    if let Some(name) = their_thread.cname() {
        imp::Thread::set_name(name);
    }

    crate::io::set_output_capture(output_capture);

    // SAFETY: the stack guard passed is the one for the current thread.
    // This means the current thread's stack and the new thread's stack
    // are properly set and protected from each other.
    thread_info::set(unsafe { imp::guard::current() }, their_thread);
    let try_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
        crate::sys_common::backtrace::__rust_begin_short_backtrace(f)
    }));
    // SAFETY: `their_packet` as been built just above and moved by the
    // closure (it is an Arc<...>) and `my_packet` will be stored in the
    // same `JoinInner` as this closure meaning the mutation will be
    // safe (not modify it and affect a value far away).
    unsafe { *their_packet.result.get() = Some(try_result) };
};

if let Some(scope_data) = &my_packet.scope {
    scope_data.increment_num_running_threads();
}

Ok(JoinInner {
    // SAFETY:
    //
    // `imp::Thread::new` takes a closure with a `'static` lifetime, since it's passed
    // through FFI or otherwise used with low-level threading primitives that have no
    // notion of or way to enforce lifetimes.
    //
    // As mentioned in the `Safety` section of this function's documentation, the caller of
    // this function needs to guarantee that the passed-in lifetime is sufficiently long
    // for the lifetime of the thread.
    //
    // Similarly, the `sys` implementation must guarantee that no references to the closure
    // exist after the thread has terminated, which is signaled by `Thread::join`
    // returning.
    native: unsafe {
        imp::Thread::new(
            stack_size,
            mem::transmute::<Box<dyn FnOnce() + 'a>, Box<dyn FnOnce() + 'static>>(
                Box::new(main),
            ),
        )?
    },
    thread: my_thread,
    packet: my_packet,
})

1.8.3. 3. thread::park() 的实现, Parker 结构如下:

pub struct Parker {
    state: AtomicUsize, // aotmic 变量
    lock: UnsafeCell<libc::pthread_mutex_t>,// 锁,  对于park()的实现 尤为重要
    cvar: UnsafeCell<libc::pthread_cond_t>,//  条件变量
    // The `pthread` primitives require a stable address, so make this struct `!Unpin`.
    _pinned: PhantomPinned,
}

1. 所以 Thread::spawn 的整体过程为: 1) builder & spawn, spawn 过程中, native::spawn + 构建 Thread 对象 2) park: 使用 Thread 对象 中的 Parker 对象, 进行 lock 操作 3) unpark
   
2. 同 Linux Programing Interface 中的 基本一致 , 只是 将 cvar lock 封装到了 同一个 Thread 中, 方便了 操作, 并扩展了 原生 Thread 的 功能
   

1.9.1. 代码整体

pub struct Sender<T> {
  inner: UnsafeCell<Flavor<T>>,
}

pub struct Receiver<T> {
    inner: UnsafeCell<Flavor<T>>,
}

enum Flavor<T> {
    Oneshot(Arc<oneshot::Packet<T>>),
    Stream(Arc<stream::Packet<T>>),
    Shared(Arc<shared::Packet<T>>),
    Sync(Arc<sync::Packet<T>>),
}

pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
    let a = Arc::new(oneshot::Packet::new());
    (Sender::new(Flavor::Oneshot(a.clone())), Receiver::new(Flavor::Oneshot(a)))
}

// stream
pub struct Packet<T> {
    // internal queue for all messages
    queue: spsc::Queue<Message<T>, ProducerAddition, ConsumerAddition>,
}

1.9.2. mpsc::channel 将创建 一个 onshot::Packet(), 所以为何怒在 Flavor的多种enum?

1.9.3. Flavor::OneShot() 为 只send(T) 一次 的优化版本, 当第二次 进行send调用时候, 将进行 upgrade 到 Flavor<Stream>

pub fn send(&self, t: T) -> Result<(), SendError<T>> {
    let (new_inner, ret) = match *unsafe { self.inner() } {
        Flavor::Oneshot(ref p) => {
            if !p.sent() { // 只能通过一次 
                return p.send(t).map_err(SendError);
            } else {
                let a = Arc::new(stream::Packet::new()); // Receiver 升级到 Stream::Packet, 这里面 的 memory layout设计 应该比较复杂,难以理解, 是否涉及到 memory 的增长方向呢? 
                let rx = Receiver::new(Flavor::Stream(a.clone()));
                match p.upgrade(rx) { // 进行upgrade
                    oneshot::UpSuccess => {
                        let ret = a.send(t);
                        (a, ret)
                    }
                    oneshot::UpDisconnected => (a, Err(t)),
                    oneshot::UpWoke(token) => {
                        // This send cannot panic because the thread is
                        // asleep (we're looking at it), so the receiver
                        // can't go away.
                        a.send(t).ok().unwrap();
                        token.signal();
                        (a, Ok(()))
                    }
                }
            }
        }
        Flavor::Stream(ref p) => return p.send(t).map_err(SendError),
        Flavor::Shared(ref p) => return p.send(t).map_err(SendError),
        Flavor::Sync(..) => unreachable!(),
    };

    unsafe {
        let tmp = Sender::new(Flavor::Stream(new_inner)); // Sender 进行升级 
        mem::swap(self.inner_mut(), tmp.inner_mut());
    }
    ret.map_err(SendError)
}

1.9.4. 整体逻辑为: 将 替换 Receiver, Sender 中的 inner Receiver { inner: UnsafeCell<Flavor::Oneshot(Arc<oneshot::Packet<T>>)> } -> Receiver { inner: UnsafeCell<Flavor::Stream(Arc<stream::Packet<T>>)> } , sender 类似

1.9.5. stream 即为 queue: 需要详细分析一下:

1.9.6. 代码如下:

pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
    let a = Arc::new(oneshot::Packet::new());
    (Sender::new(Flavor::Oneshot(a.clone())), Receiver::new(Flavor::Oneshot(a)))
}

pub struct Sender<T> {
    inner: UnsafeCell<Flavor<T>>,
}

enum Flavor<T> {
    Oneshot(Arc<oneshot::Packet<T>>),
    Stream(Arc<stream::Packet<T>>),
    Shared(Arc<shared::Packet<T>>),
    Sync(Arc<sync::Packet<T>>),
}

// stream::Packet<T>
pub struct Packet<T> {
    // internal queue for all messages
    queue: spsc::Queue<Message<T>, ProducerAddition, ConsumerAddition>,
}

pub struct Queue<T, ProducerAddition = (), ConsumerAddition = ()> {
    // consumer fields
    consumer: CacheAligned<Consumer<T, ConsumerAddition>>,

    // producer fields
    producer: CacheAligned<Producer<T, ProducerAddition>>,
}
pub(super) struct CacheAligned<T>(pub T);

struct Consumer<T, Addition> {
    tail: UnsafeCell<*mut Node<T>>, // where to pop from
    tail_prev: AtomicPtr<Node<T>>,  // where to pop from
    cache_bound: usize,             // maximum cache size
    cached_nodes: AtomicUsize,      // number of nodes marked as cacheable
    addition: Addition,
}

struct Producer<T, Addition> {
    head: UnsafeCell<*mut Node<T>>,      // where to push to
    first: UnsafeCell<*mut Node<T>>,     // where to get new nodes from
    tail_copy: UnsafeCell<*mut Node<T>>, // between first/tail
    addition: Addition,
}

struct ProducerAddition {
    cnt: AtomicIsize,       // How many items are on this channel
    to_wake: AtomicPtr<u8>, // SignalToken for the blocked thread to wake up

    port_dropped: AtomicBool, // flag if the channel has been destroyed.
}

struct ConsumerAddition {
    steals: UnsafeCell<isize>, // How many times has a port received without blocking?
}

// so the sender & receiver 's type is:

Sender {
 inner: UnsafeCell<Flavor::Stream<Arc<stream::Packet {
     queue: spsc::Queue {
        consumer: CacheAligned(pub Consumer<T, ConsumerAddition> {
           tail: UnsafeCell<*mut Node<T>>,
           tail_prev: AtomicPtr<Node<T>>,
           cache_bound: usize,
           cached_nodes: AotmicUsize,
           addition: ConsumerAddition,
        })
        producer: Producer<T, ProducerAddition> {
          head: UnsafeCell<*mut Node<T>>,      // where to push to
          first: UnsafeCell<*mut Node<T>>,     // where to get new nodes from
          tail_copy: UnsafeCell<*mut Node<T>>, // between first/tail
          addition: ProducerAddition,
        }
      },
    }>>>
}

Receiver {
 inner: UnsafeCell<Flavor::Stream<Arc<stream::Packet {
     queue: spsc::Queue {
        consumer: CacheAligned(pub Consumer<T, ConsumerAddition> {
           tail: UnsafeCell<*mut Node<T>>,
           tail_prev: AtomicPtr<Node<T>>,
           cache_bound: usize,
           cached_nodes: AotmicUsize,
           addition: ConsumerAddition,
        })
        producer: Producer<T, ProducerAddition> {
          head: UnsafeCell<*mut Node<T>>,      // where to push to
          first: UnsafeCell<*mut Node<T>>,     // where to get new nodes from
          tail_copy: UnsafeCell<*mut Node<T>>, // between first/tail
          addition: ProducerAddition,
        }
      },
    }>>>

impl<T> Packet<T> {
    pub fn new() -> Packet<T> {
        Packet {
            queue: unsafe {
                spsc::Queue::with_additions(
                    128,
                    ProducerAddition {
                        cnt: AtomicIsize::new(0),
                        to_wake: AtomicPtr::new(EMPTY),

                        port_dropped: AtomicBool::new(false),
                    },
                    ConsumerAddition { steals: UnsafeCell::new(0) },
                )
            },
        }
    }
  }
}

1.9.7. Sender & Receiver 共享 inner 中的 Arc<stream::Packet>, 主要为queue

1.9.8. Queue: 中 consumer & producer 使用链表, 共享 同样的内存空间

1.9.9. ConsumerAddition, ProducerAddition: ProducerAddition 中比较重要,

1. 1. 其中的 to_wake 为 SignalToken的指针, 当 Receiver 在 recv() 阻塞时候,会 填充 producer.addition.to_wake, 当producer.send() 时候,会 唤醒 recv
   
2. 2. sender.send 并不会 阻塞, 因为 多个 Sender ? 反而 阻塞 receiver.recv ? 为什么 会如此设计?
   
3. https://doc.rust-lang.org/std/sync/mpsc/ 查询 文档 可知,
   
4. channnel 存在 1) 无bound 即 有 infinite buffer 2) bound buff, 即 pre-allocate fixed buff
   
5. bound buff 会阻塞 Sender.send 操作
   
6. sync_channle 中的 Buffer 为一个 ring buff
   
   1. 环形 buff, 只需要 保持 start + size 两个变量, 即可
      
   2. 1. push/enqueue: 将size + 1, pos = (start + size) / buff.len
      
   3. 2. pop/denque: 将 pos = start, start += 1, size - 1
      
   4. 可以保持 size 永远小于 buff.len()
      
   5. start 为 首, (start + size) / buff.len() 为 尾部
      
   6. 但是 该种 实现, 导致 每次操作 都需要 lock的帮助, 实现完全的互斥, 才能 保证操作完整
      

      impl<T> Buffer<T> {
          fn enqueue(&mut self, t: T) {
              let pos = (self.start + self.size) % self.buf.len();
              self.size += 1;
              let prev = mem::replace(&mut self.buf[pos], Some(t));
              assert!(prev.is_none());
          }
      
          fn dequeue(&mut self) -> T {
              let start = self.start;
              self.size -= 1;
              self.start = (self.start + 1) % self.buf.len();
              let result = &mut self.buf[start];
              result.take().unwrap()
          }
      
          fn size(&self) -> usize {
              self.size
          }
          fn capacity(&self) -> usize {
              self.buf.len()
          }
      }
      

1.9.10.

2.2.1. Result core 中自定义了 Result 为一个 enum, 而并没有定义E 的类型

2.2.2. std 库 定义了 多种 Error 类型, 包括 std::io::Error, std::fmt::Error, std::num::ParseIntError … etc,每种 自定义Error 不尽相同:

2.2.3. std::error: 提供 构建、 handle、 report、 propagating Rust 错误, 构建(表示 ) 即为: Result, error trait , custome types & failure 处理模式:

2.2.4. trait: Error : Debug + Display {} 表达错误的基本结构, description(), cause(), type_id() etc…

2.2.5. Box<dyn Error + 'a> {fn from(err: E) -> Box<dyn Error + 'a> {Box::new(err)};

2.2.6. Report: 提供 error 的格式化工作, (通过配置 来控制 )

2.5.1. 1. 定义: struct Error, enum ErrorKind, Error(ErrorKind, State)

enum pub enum ErrorKind {
  IoErr(std::io::Error),
  Msg(String),
  InvalidToken(String),
}

2.5.2. 2. impl From<xxx> for Error {}, 实现 ?

impl <'a>From<&'a str>for Error {
  fn from(s: &'a str) -> Self {
    Self::from_kind(s.into())
  }
}
impl From<String>for Error {
  fn from(s:String) -> Self {
    Self::from_kind(s.into())
  }
}

impl From<std::io::Error>for Error {
  fn from(e:std::io::Error) -> Self {
    Error::from_kind(ErrorKind::IoErr(e))
  }
 }
impl From<std::num::ParseIntError>for Error {
  fn from(e:std::num::ParseIntError) -> Self {
    Error::from_kind(ErrorKind::ParseErr(e))
  }
}

impl <'a>From<&'a str>for ErrorKind {
  fn from(s: &'a str) -> Self {
    ErrorKind::Msg(s.into())
  }

}
impl From<String>for ErrorKind {
  fn from(s:String) -> Self {
    ErrorKind::Msg(s)
  }
}

2.5.3. 3. 重新定义 Result: pub type Result<T> = ::std::result::Result<T,Error>;

2.6.1. types: 从macro的展开结果看： 为 自定义 Error， ErrorKind, Result 名称, 不应该自定义 Result名字，而应该使用 Result

error_chain! {
    types {
        MyError, MyErrorKind, MyResult;
    }
}
// expand 展开如下：

pub struct MyError(
  pub MyErrorKind,
  pub $crate::State,
);

pub enum MyErrorKind {
  Msg(String),
  __Nonexhaustive{}

}

2.6.2. errors: 为 ErrorKind 增加 ErrorKind 类型, 如下: 主要为 chain_err(error: F) F: FnOnce() -> EK: Into<ErrorKind> 使用

  error_chain! {
      foreign_links {
          IoErr(std::io::Error);
          ParseErr(std::num::ParseIntError);
      }

      // 定义新的  ErrorKind enum; enum { InvalidToken(String) }
      errors {
          InvalidToken(t: String) {
              description("invalid token")
              display("invalid token display")
          }
      }
  }

 errors {
     InvalidToken(t: String) {
         description("invalid token")
         display("invalid token display")
     }
 }
pub enum ErrorKind {
  IoErr(std::io::Error), #[doc = " A convenient variant for String."]
  Msg(String),InvalidToken(String), #[doc(hidden)]
  __Nonexhaustive{}

}
xx.chain_err(|| ErrorKind::InvalidToken("xx".to_string()))

2.6.3. foreign_links: 实现 foreign error(外部的error定义) 到 ErrorKind的转换:

 error_chain! {
     foreign_links {
         IoErr(std::io::Error);
         ParseErr(std::num::ParseIntError);
     }
 }

// expand 如下：
impl From<std::io::Error>for Error {
  fn from(e:std::io::Error) -> Self {
    Error::from_kind(ErrorKind::IoErr(e))
  }
}

impl From<std::num::ParseIntError>for Error {
  fn from(e:std::num::ParseIntError) -> Self {
    Error::from_kind(ErrorKind::ParseErr(e))
  }
}

2.6.4. ErrorKind::Msg 为 方便 使用 &str, String 定义error 而定义的ErrorKind Variant,

impl < 'a>From<& 'a str>for ErrorKind {
  fn from(s: & 'a str) -> Self {
    ErrorKind::Msg(s.into())
  }
}
impl From<String>for ErrorKind {
  fn from(s:String) -> Self {
    ErrorKind::Msg(s)
  }
}

2.6.5. links: 将其他的 error_chain 中定义的 Error 转换到 当前的Error中

pub mod errors {
    // Create the Error, ErrorKind, ResultExt, and Result types
    error_chain! {
        foreign_links {
            IoErr(std::io::Error);
            ParseErr(std::num::ParseIntError);
        }
}

error_chain! {
  links {
    Other(errors::Error, errors::ErrorKind)
  }
}

// expand 如下
pub enum ErrorKind {
  Other(errors::ErrorKind)
  Msg(String), #[doc(hidden)]
  __Nonexhaustive{}
}

impl From<errors::Error>for Error {
  fn from(e:errors::Error) -> Self {
    Error(ErrorKind::Other(e.0),e.1,)
  }
}

impl From<errors::ErrorKind>for ErrorKind {
  fn from(e:errors::ErrorKind) -> Self {
    ErrorKind::Other(e)
  }
}

4.2.1. types(redis 数据类型 到rust 类型的映射), client, connection, cmd, pipeline

4.2.2. connection: 实现了 连接、操作redis的能力

4.2.3. types: 如何在redis typeless 到 rust type 之间进行转换

4.2.4. macro 的使用方法

4.3.1. 构建Cmd 可以使用 default/cmd("get")

4.3.2. Cmd 直接 get,hget etc… 命令在

4.3.3. 为Cmd 增加方法的 主要有 impl Cmd; impl RedisWrite; impl Default, 以及重要的 implement_commands! macro 展开形式如下:

   impl Cmd {
     #[doc = " Get the value of a key.  If key is a vec this becomes an `MGET`."]
     #[allow(clippy::extra_unused_lifetimes,clippy::needless_lifetimes)]
     pub fn get<'a,K:ToRedisArgs>(key:K) -> Self {
       ::std::mem::replace({
         cmd(if key.is_single_arg(){
           "GET"
         }else {
           "MGET"
         }).arg(key)
       },Cmd::new())
     }
     #[doc = " Gets all keys matching pattern"]
     #[allow(clippy::extra_unused_lifetimes,clippy::needless_lifetimes)]
     pub fn keys<'a,K:ToRedisArgs>(key:K) -> Self {
       ::std::mem::replace({
         cmd("KEYS").arg(key)
       },Cmd::new())
     }
  }
pub trait Commands:ConnectionLike+Sized {
  #[doc = " Get the value of a key.  If key is a vec this becomes an `MGET`."]
  #[inline]
  #[allow(clippy::extra_unused_lifetimes,clippy::needless_lifetimes)]
  fn get<'a,K:ToRedisArgs,RV:FromRedisValue>(&mut self,key:K) -> RedisResult<RV>{
    Cmd::get(key).query(self)
  }
}

4.5.1. ToRedisValue: 不需要看太多内容

4.5.2. FromRedisValue: 大多 都已 macro 完成: 以 i8 为例:

4.5.3. 需要注意 nil 的转换, 在对 i8 的转换代码中, 并没有对 Value::Nil 的匹配

4.5.4. 即简单命令 let res: RedisResult<i64> = cli.get("xx"); 如果xx 没有设定数值的话, 会导致 一直返回错误, 正确的方法是是 let res: RedisResult<Option<i64>> = cli.get("xx");

4.5.5. 但是: HashMap<String, String>, 以及 Vec, Set 等集合类, 这是一个例外, 即便是 没有 key, 依然返回一个 empty 的集合

pub enum Value {
    /// A nil response from the server.
    Nil,
    /// An integer response.  Note that there are a few situations
    /// in which redis actually returns a string for an integer which
    /// is why this library generally treats integers and strings
    /// the same for all numeric responses.
    Int(i64),
    /// An arbitary binary data.
    Data(Vec<u8>),
    /// A bulk response of more data.  This is generally used by redis
    /// to express nested structures.
    Bulk(Vec<Value>),
    /// A status response.
    Status(String),
    /// A status response which represents the string "OK".
    Okay,
}

from_redis_value_for_num!(i8); // 展开结构如下:
impl FromRedisValue for i8 {
  fn from_redis_value(v: &Value) -> RedisResult<i8>{
    {
      let v = v;
      match*v {
        Value::Int(val) => Ok(val as i8),
        Value::Status(ref s) => match s.parse::<i8>(){
          Ok(rv) => Ok(rv),
          Err(_) => {
            return Err(::std::convert::From::from((RedisError::from((ErrorKind::TypeError,"Response was of incompatible type",{
              let res = $crate::fmt::format(unsafe {
                std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&("Could not convert from string."),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(v),std::fmt::Display::fmt),])
              });
              res
            },)))))
          },

          },
        Value::Data(ref bytes) => match from_utf8(bytes)?.parse::<i8>(){
          Ok(rv) => Ok(rv),
          Err(_) => {
            return Err(::std::convert::From::from((RedisError::from((ErrorKind::TypeError,"Response was of incompatible type",{
              let res = $crate::fmt::format(unsafe {
                std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&("Could not convert from string."),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(v),std::fmt::Display::fmt),])
              });
              res
            },)))))
          },

          },
        _ => {
          return Err(::std::convert::From::from((RedisError::from((ErrorKind::TypeError,"Response was of incompatible type",{
            let res = $crate::fmt::format(unsafe {
              std::fmt::Arguments::new_v1(&[], &[std::fmt::ArgumentV1::new(&("Response type not convertible to numeric."),std::fmt::Display::fmt),std::fmt::ArgumentV1::new(&(v),std::fmt::Display::fmt),])
            });
            res
          },)))))
        },

        }
    }
  }

  }

1. 更过细节在 Connection.read_response 中, 并调用 self.parser.parse_value(sock) 即: 读取字节流 并进行转换, 代码如下:
   

       fn read_response(&mut self) -> RedisResult<Value> {
           let result = match self.con {
               ActualConnection::Tcp(TcpConnection { ref mut reader, .. }) => {
                   self.parser.parse_value(reader)
               }
               #[cfg(feature = "tls")]
               ActualConnection::TcpTls(ref mut boxed_tls_connection) => {
                   let reader = &mut boxed_tls_connection.reader;
                   self.parser.parse_value(reader)
               }
               #[cfg(unix)]
               ActualConnection::Unix(UnixConnection { ref mut sock, .. }) => {
                   self.parser.parse_value(sock)
               }
           };
           // shutdown connection on protocol error
           if let Err(e) = &result {
               let shutdown = match e.as_io_error() {
                   Some(e) => e.kind() == io::ErrorKind::UnexpectedEof,
                   None => false,
               };
               if shutdown {
                   match self.con {
                       ActualConnection::Tcp(ref mut connection) => {
                           let _ = connection.reader.shutdown(net::Shutdown::Both);
                           connection.open = false;
                       }
                       #[cfg(feature = "tls")]
                       ActualConnection::TcpTls(ref mut connection) => {
                           let _ = connection.reader.shutdown();
                           connection.open = false;
                       }
                       #[cfg(unix)]
                       ActualConnection::Unix(ref mut connection) => {
                           let _ = connection.sock.shutdown(net::Shutdown::Both);
                           connection.open = false;
                       }
                   }
               }
           }
           result
       }
   
   impl Parser {
       /// Creates a new parser that parses the data behind the reader.  More
       /// than one value can be behind the reader in which case the parser can
       /// be invoked multiple times.  In other words: the stream does not have
       /// to be terminated.
       pub fn new() -> Parser {
           Parser {
               decoder: combine::stream::decoder::Decoder::new(),
           }
       }
   
       // public api
   
       /// Parses synchronously into a single value from the reader.
       pub fn parse_value<T: Read>(&mut self, mut reader: T) -> RedisResult<Value> {
           let mut decoder = &mut self.decoder;
           //转换为了  macro调用
           let result = combine::decode!(decoder, reader, value(), |input, _| {
               combine::stream::easy::Stream::from(input)
           });
           match result {
               Err(err) => Err(match err {
                   combine::stream::decoder::Error::Io { error, .. } => error.into(),
                   combine::stream::decoder::Error::Parse(err) => {
                       if err.is_unexpected_end_of_input() {
                           RedisError::from(io::Error::from(io::ErrorKind::UnexpectedEof))
                       } else {
                           let err = err
                               .map_range(|range| format!("{:?}", range))
                               .map_position(|pos| pos.translate_position(decoder.buffer()))
                               .to_string();
                           RedisError::from((ErrorKind::ResponseError, "parse error", err))
                       }
                   }
               }),
               Ok(result) => result,
           }
       }
   }
   

5.4.1. 因为 该种结构 可能需要move，即： 使用 mem::swap（one, two）， 该函数接受任何类型的 &mut ref， 使用 memcpy 对内存进行交换。

5.4.2. memcpy 并不适合 对于 包含 self-ref 的结构进行 交换， 将导致 指针错乱，详见： https://rust-lang.github.io/async-book/04_pinning/01_chapter.html#pinning

5.4.3. Pin 的doc为https://doc.rust-lang.org/std/pin/index.html

5.5.1. 其中有对 为什么 会Future要求Pin 的要求，进行了基本的解释， 比如 async {} 转换为 类似对应的 Future（其中包含了 self-ref ） example：

async {
    let mut x = [0; 128];
    let read_into_buf_fut = read_into_buf(&mut x);
    read_into_buf_fut.await;
    println!("{:?}", x);

}

//compile to below like
struct ReadIntoBuf<'a> {
    buf: &'a mut [u8], // points to `x` below
}

struct AsyncFuture {
    x: [u8; 128],
    read_into_buf_fut: ReadIntoBuf<'what_lifetime?>,
}

//AsyncFuture 包含 内部 fut 需要的 变量 x， ReadIntoBuf 则 包含指向 AsyncFuture 的指针，即： 构成了 Self-ref 结构。
//即：如果将 AsyncFuture swap出去， 将导致 指针的混乱。

5.5.2. Pin wrap pointers type， guarantee the value behind the pointer, won't be moved, T: !Unpin then Pin<&mut T>, Pin<&T>, Pin<Box<T>> 保证T不被移动，

5.5.3. Future/Stream 从 Pin 到Unpin 的转换： Box::pin(Fut) => Pin<Box<Fut>>, pin_utils::pin_mut!(fut) => Pin<&mut Fut> 即 => 后的实现 都是impl Unpin

5.5.4. summary:

1. if T: Unpin then Pin<'a, T> impl Unpin
   
2. T: !Unpin, &mut T => Pin<T> 的转换 需要unsafe 代码
   
3. 大部分的type 以及有这些type组成的struct impl Unpin, async/await 自动生成的 Future 是一个意外
   
4. 实现!Unpin 的方法： 1) impl !Unpin 在 nightly + feature flag 2) 添加 std::marker::PhantomPinned field到 struct
   
5. Pin 在stack 的var，需要使用unsafe code
   
6. Pin 在heap上的var， 可以使用 Box::pin
   
7. For pinned data where T: !Unpin you have to maintain the invariant that its memory will not get invalidated or repurposed from the moment it gets pinned until when drop is called. This is an important part of the pin contract.
   

5.6.1. 1. 测试一下，直接 mem::swap(&mut Pin<T>, &mut Pin<T>) ;

5.6.2. 2. 基本上所有的type 都会自动实现 Unpin, Future 是一个意外（需要查找 async function rust auto generator的示例 才能更深入的理解）

5.6.3. 3. T: is Unpin, then Pin<Box<T>>, Box<T>, Pin<&mut T>, &mut T 都是 Unpin 的

5.6.4. 4. Pin<Box<T>>

5.6.5.

5.9.1. mem::swap(&mut Pin<Box<T>>, &mut Pin); T: !Unpin 可以的

9.1.1. #[tokio:main]: 将 main函数 转换为 async 然后 自动 构建 let r = runtime::Builder::new(); r.block_on(整体的 func)

9.1.2. runtime.block_on(async future) 直接收 async func， 并 调用 exec.block_on(future) 以执行 future

9.1.3. .await 只能在 async function中 调用, 即: 1) await 只为 async fun 准备, 2) await 将 future 转换为 Generator 的状态机 3) await 顺序执行, 执行一次, loop 为 server 循环处理 client的 关键逻辑

9.1.4. block_on(future) 为 阻塞调用, 一直 poll 直到 future完成

9.1.5. spawn 则直接spawn task,交由 runtime去执行

9.1.6. ? tokio 如何实现的 sleep ? 为什么 Sleep 并没有实现 Future?

9.3.1. 1. std::net::TcpStream, 因为需要保持 socket 的多处ref & 可写, 导致 需要使用 RefCell, 而 RefCell 是 !Sync 导致, Mutex<RefCell<TcpStream>> 不能够 Send + Sync, 因为 Mutex 的签名 为: impl<T: ?Sized + Send> Send for Mutex<T>, impl<T: ?Sized + Send> Sync for Mutex<T>

9.3.2. 2. tokio::net::TcpStream 因为 是 Sync & Send, 所以实现了 如下的代码包装: 其中存在的问题为, 经常出现“死锁”情况. 并且 无法避免: 因为 一个read 完成之后,会进入另一个 循环,进行read, 并且 总是在read中, read 会把持 lock, 导致, public_msg 无法进行完全.

9.3.3. 3. 所以, 使用 Mutex 对 Fd 进行加锁的行为, 不可行.(因为无法避免 fd 在等待 read)

#[derive(Clone)]
struct SocketWrapper {
    inner: Arc<Mutex<TcpStream>>,
    eq: SocketAddr,
}
impl Deref for SocketWrapper {
    type Target = Arc<Mutex<TcpStream>>;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl DerefMut for SocketWrapper {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

impl SocketWrapper {
    fn new(socket: Arc<Mutex<TcpStream>>, eq: SocketAddr) -> SocketWrapper {
        SocketWrapper { inner: socket, eq }
    }
}
impl PartialEq for SocketWrapper {
    fn eq(&self, other: &SocketWrapper) -> bool {
        self.eq.eq(&other.eq)
    }

    fn ne(&self, other: &SocketWrapper) -> bool {
        self.eq.ne(&other.eq)
    }
}
impl Hash for SocketWrapper {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.eq.hash(state);
    }
}

impl fmt::Debug for SocketWrapper {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "addr: {}", self.eq)
    }
}
impl Eq for SocketWrapper {}

let chat_room: Mutex<HashMap<String, HashSet<SocketWrapper>>> = Mutex::new(HashMap::new());
// 主体结构如下:
fn main() {
    let addr = env::args()
        .nth(1)
        .unwrap_or_else(|| "127.0.0.1:8080".to_string());

    // Next up we create a TCP listener which will listen for incoming
    // connections. This TCP listener is bound to the address we determined
    // above and must be associated with an event loop.

    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    let chat_room: Mutex<HashMap<String, HashSet<SocketWrapper>>> = Mutex::new(HashMap::new());
    let chat_room = Arc::new(chat_room);

    runtime.block_on(async {
        let listener = TcpListener::bind(&addr).await.unwrap();
        // let mut db: Arc<Mutex<HashMap<String, HashSet<TcpStream>>>> =
        //     Arc::new(Mutex::new(HashMap::default()));
        loop {
            let (mut socket, addr) = listener.accept().await.unwrap();
            let peer_addr = socket.peer_addr().unwrap();
            let socket = Arc::new(Mutex::new(socket));
            let socket_fd = SocketWrapper::new(socket, peer_addr);
            // println!("filename: {:?}", socket.to_m.file_name_ref());
            // println!("socket: {:?}", socket.peer_addr());
            // let chat = chat_room.clone();
            // let socket = SocketWrapper::new(socket, socket.peer_addr());

            let i_chat = chat_room.clone();
            // let idb = db.clone();
            // let mut chat = db.clone();
            tokio::spawn(async move { socket_handler(socket_fd, i_chat).await });
        }
    })
}

async fn socket_handler(
    socket: SocketWrapper,
    db: Arc<Mutex<HashMap<String, HashSet<SocketWrapper>>>>,
) {
    let mut buf = vec![0; 1024];
    let mut n = 0;
    loop {
        {
            n = socket
                .lock()
                .await
                .read(&mut buf)
                .await
                .expect("failed to read data from socket");
        }

        if n == 0 {
            return;
        }
        let istr: String = String::from_utf8_lossy(&buf[0..n]).into_owned();
        // split by : , room, msg;
        let mut iter = istr.split(":");
        let room = iter.next().unwrap_or("global");
        let msg = iter.next();
        let i_db = db.clone();

        {
            let mut lock = i_db.lock().await;
            let mut val = lock.entry(room.to_owned()).or_insert(HashSet::new());
            val.insert(socket.clone());
        }
        println!(
            "istr: {:?}, room: {:?}, msg: {:?}, db: {:?}",
            istr, room, msg, db
        );

        {
            if let Some(i_msg) = msg {
                publish_msg(room, i_msg, db.clone()).await;
            }
        }

        {
            socket
                .lock()
                .await
                .write_all(&buf[0..n])
                .await
                .expect("failed to write data to socket");
        }
        n = 0;
    }
}
async fn publish_msg(
    room: &str,
    msg: &str,
    db: Arc<Mutex<HashMap<String, HashSet<SocketWrapper>>>>,
) {
    println!("publish_msg begin");
    if let Some(pepoles) = db.lock().await.get(room) {
        println!("****************************************************************************************************");
        for s in pepoles.iter() {
            s.lock().await.write(&msg.as_ref()).await;
        }
    }
    println!("publish_msg done");
}

9.4.1. mio::Poll : 屏蔽 各个平台实现的 EventLoop : (linux epoll)

9.4.2. 大概的使用方法为:

let poll = Poll::new()?;
let socket = TcpStream::connect(&"216.58.193.100:80".parse()?)?;
// the socket with `poll`, requesting readable
poll.register(&socket, Token(0), Ready::readable(), PollOpt::edge())?;


// Poll 结构比较重要:

pub struct Poll {
    // Platform specific IO selector
    selector: sys::Selector,

    // Custom readiness queue
    readiness_queue: ReadinessQueue,

    // Use an atomic to first check if a full lock will be required. This is a
    // fast-path check for single threaded cases avoiding the extra syscall
    lock_state: AtomicUsize,

    // Sequences concurrent calls to `Poll::poll`
    lock: Mutex<()>,

    // Wakeup the next waiter
    condvar: Condvar,
}

9.4.3. 经过层层调用, 最终 调用为 Selector.register()

9.4.4. Poll.poll(&mut events) 中的代码比较复杂: 需要重新看

9.4.5. Poll.register 方法比较 有意思: 这其中隐含着 rust的代码设计模式, 值得思考, 如何范化 参数限制

// 这里 使用了 generic template, 但是对E 做了impl的限制
pub fn register<E: ?Sized>(&self, handle: &E, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()>
    where E: Evented
{
    validate_args(token)?;

    /*
     * Undefined behavior:
     * - Reusing a token with a different `Evented` without deregistering
     * (or closing) the original `Evented`.
     */
    trace!("registering with poller");

    // Register interests for this socket
    // 这里 将 方法调用 转身 传递给了 handle 参数
    handle.register(self, token, interest, opts)?;

    Ok(())
}

9.4.6.

9.5.1. Events: A collection of readiness events

/// Representation of a spawned future/stream.
///
/// This object is returned by the `spawn` function in this module. This
/// represents a "fused task and future", storing all necessary pieces of a task
/// and owning the top-level future that's being driven as well.
///
/// A `Spawn` can be poll'd for completion or execution of the current thread
/// can be blocked indefinitely until a notification arrives. This can be used
/// with either futures or streams, with different methods being available on
/// `Spawn` depending which is used.
pub struct Spawn<T: ?Sized> {
    id: usize,
    data: LocalMap,
    obj: T,
}


/// Pre-allocated storage for a uniform data type
///
/// See [module documentation] for more details.
///
/// [module documentation]: index.html
#[derive(Clone)]
pub struct Slab<T> {
    // Chunk of memory
    entries: Vec<Entry<T>>,

    // Number of Filled elements currently in the slab
    len: usize,

    // Offset of the next available slot in the slab. Set to the slab's
    // capacity when the slab is full.
    next: usize,
}

/// An event loop.
///
/// The event loop is the main source of blocking in an application which drives
/// all other I/O events and notifications happening. Each event loop can have
/// multiple handles pointing to it, each of which can then be used to create
/// various I/O objects to interact with the event loop in interesting ways.
// TODO: expand this
pub struct Core {
    events: mio::Events,
    tx: mpsc::UnboundedSender<Message>,
    rx: RefCell<Spawn<mpsc::UnboundedReceiver<Message>>>,
    _rx_registration: mio::Registration,
    rx_readiness: Arc<MySetReadiness>,

    inner: Rc<RefCell<Inner>>,

    // Used for determining when the future passed to `run` is ready. Once the
    // registration is passed to `io` above we never touch it again, just keep
    // it alive.
    _future_registration: mio::Registration,
    future_readiness: Arc<MySetReadiness>,
}


/// A collection of readiness events.
///
/// `Events` is passed as an argument to [`Poll::poll`] and will be used to
/// receive any new readiness events received since the last poll. Usually, a
/// single `Events` instance is created at the same time as a [`Poll`] and
/// reused on each call to [`Poll::poll`].
///
/// See [`Poll`] for more documentation on polling.
///
/// # Examples
///
/// ```
/// # use std::error::Error;
/// # fn try_main() -> Result<(), Box<Error>> {
/// use mio::{Events, Poll};
/// use std::time::Duration;
///
/// let mut events = Events::with_capacity(1024);
/// let poll = Poll::new()?;
///
/// assert_eq!(0, events.len());
///
/// // Register `Evented` handles with `poll`
///
/// poll.poll(&mut events, Some(Duration::from_millis(100)))?;
///
/// for event in &events {
///     println!("event={:?}", event);
/// }
/// #     Ok(())
/// # }
/// #
/// # fn main() {
/// #     try_main().unwrap();
/// # }
/// ```
///
/// [`Poll::poll`]: struct.Poll.html#method.poll
/// [`Poll`]: struct.Poll.html
pub struct Events {
    inner: sys::Events,
}

pub struct Events {
    sys_events: KeventList,
    events: Vec<Event>,
    event_map: HashMap<Token, usize>,
}

struct KeventList(Vec<libc::kevent>);

/// [`Token`]: ../struct.Token.html
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct Event {
    kind: Ready,
    token: Token
}

9.5.2. Runtime:

9.5.3. source code

    /// cpu-pool  代码 ----------------------------------
    /// A thread pool intended to run CPU intensive work.
    /// 使用 Thread Pool 执行 task
    pub struct CpuPool {
        inner: Arc<Inner>,
    }

    impl Builder {
        pub fn create(&mut self) -> CpuPool {
            let (tx, rx) = mpsc::channel();
            let pool = CpuPool {
                inner: Arc::new(Inner {
                    tx: Mutex::new(tx),
                    rx: Mutex::new(rx),
                    cnt: AtomicUsize::new(1),
                    size: self.pool_size,
                }),
            };
            assert!(self.pool_size > 0);

            for counter in 0..self.pool_size {
                let inner = pool.inner.clone();
                let after_start = self.after_start.clone();
                let before_stop = self.before_stop.clone();
                let mut thread_builder = thread::Builder::new();
                if let Some(ref name_prefix) = self.name_prefix {
                    thread_builder = thread_builder.name(format!("{}{}", name_prefix, counter));
                }
                if self.stack_size > 0 {
                    thread_builder = thread_builder.stack_size(self.stack_size);
                }
                thread_builder.spawn(move || inner.work(after_start, before_stop)).unwrap();
            }
            return pool
        }
    }

    impl Inner {
        fn send(&self, msg: Message) {
            self.tx.lock().unwrap().send(msg).unwrap();
        }

        fn work(&self, after_start: Option<Arc<Fn() + Send + Sync>>, before_stop: Option<Arc<Fn() + Send + Sync>>) {
            after_start.map(|fun| fun());
            loop {
                let msg = self.rx.lock().unwrap().recv().unwrap();
                match msg {
                    Message::Run(r) => r.run(),
                    Message::Close => break,
                }
            }
            before_stop.map(|fun| fun());
        }
    }

    impl Run {
        /// Actually run the task (invoking `poll` on its future) on the current
        /// thread.
        #[allow(deprecated)]
        pub fn run(self) {
            let Run { mut spawn, inner } = self;

            // SAFETY: the ownership of this `Run` object is evidence that
            // we are in the `POLLING`/`REPOLL` state for the mutex.
            unsafe {
                inner.mutex.start_poll();

                loop {
                    let unpark: Arc<Unpark> = inner.clone();
                    match spawn.poll_future(unpark) { /// 这里 为 Future 执行的地方， spawn: Spawn<Box<MySender>> 
                        Ok(Async::NotReady) => {}
                        Ok(Async::Ready(())) |
                        Err(()) => return inner.mutex.complete(),
                    }
                    let run = Run { spawn: spawn, inner: inner.clone() };
                    match inner.mutex.wait(run) {
                        Ok(()) => return,            // we've waited
                        Err(r) => spawn = r.spawn,   // someone's notified us
                    }
                }
            }
        }
    }

    impl Executor for Inner {
        fn execute(&self, run: Run) {
            self.send(Message::Run(run))
        }
    }

    impl CpuPool {
        /// Panics if `size == 0`.
        pub fn new(size: usize) -> CpuPool {
            Builder::new().pool_size(size).create()
        }


        /// Spawns a closure on this thread pool.
        ///
        /// This function is a convenience wrapper around the `spawn` function above
        /// for running a closure wrapped in `future::lazy`. It will spawn the
        /// function `f` provided onto the thread pool, and continue to run the
        /// future returned by `f` on the thread pool as well.
        ///
        /// The returned future will be a handle to the result produced by the
        /// future that `f` returns.
        pub fn spawn_fn<F, R>(&self, f: F) -> CpuFuture<R::Item, R::Error>
        where F: FnOnce() -> R + Send + 'static,
              R: IntoFuture + 'static,
              R::Future: Send + 'static,
              R::Item: Send + 'static,
              R::Error: Send + 'static,
        {
            self.spawn(lazy(f))
        }

        pub fn spawn<F>(&self, f: F) -> CpuFuture<F::Item, F::Error>
        where F: Future + Send + 'static,
              F::Item: Send + 'static,
              F::Error: Send + 'static,
        {
            let (tx, rx) = channel(); ///创建 f：F 执行结果 传递通道
            let keep_running_flag = Arc::new(AtomicBool::new(false));
            // AssertUnwindSafe is used here because `Send + 'static` is basically
            // an alias for an implementation of the `UnwindSafe` trait but we can't
            // express that in the standard library right now.
            let sender = MySender { /// 主要的运算 载体， 其中包含 tx, 将结果发送的 sender, 包含 fut
                fut: AssertUnwindSafe(f).catch_unwind(),
                tx: Some(tx), /// 在runner 实体 中 保持 sender
                keep_running_flag: keep_running_flag.clone(),
            };
            executor::spawn(sender).execute(self.inner.clone());
            CpuFuture { inner: rx , keep_running_flag: keep_running_flag.clone() } /// 接受 f：F 的结果
        }
    }

    /// Future 执行的地方 
    impl<F: Future> Future for MySender<F, Result<F::Item, F::Error>> {
        type Item = ();
        type Error = ();

        fn poll(&mut self) -> Poll<(), ()> {
            if let Ok(Async::Ready(_)) = self.tx.as_mut().unwrap().poll_cancel() {
                if !self.keep_running_flag.load(Ordering::SeqCst) {
                    // Cancelled, bail out
                    return Ok(().into())
                }
            }

            let res = match self.fut.poll() {
                Ok(Async::Ready(e)) => Ok(e),
                Ok(Async::NotReady) => return Ok(Async::NotReady),
                Err(e) => Err(e),
            };

            // if the receiving end has gone away then that's ok, we just ignore the
            // send error here.
            drop(self.tx.take().unwrap().send(res));
            Ok(Async::Ready(()))
        }
    }

     /// spawn_fun  与 cpupool  之间的 消息结构，  
     enum Message {
         Run(Run),
         Close,
     }

     /// Units of work submitted to an `Executor`, currently only created
     /// internally.
     pub struct Run {
         spawn: Spawn<Box<Future<Item = (), Error = ()> + Send>>, /// 这里面 为 Spawn<Box<MySender>> 
         inner: Arc<RunInner>,
     }

      /// The type of future returned from the `CpuPool::spawn` function, which
      /// proxies the futures running on the thread pool.
      ///
      /// This future will resolve in the same way as the underlying future, and it
      /// will propagate panics.
      #[must_use]
      #[derive(Debug)]
      pub struct CpuFuture<T, E> {
          inner: Receiver<thread::Result<Result<T, E>>>,
          keep_running_flag: Arc<AtomicBool>,
      }

     impl<T: Send + 'static, E: Send + 'static> Future for CpuFuture<T, E> {
       type Item = T;
       type Error = E;

       fn poll(&mut self) -> Poll<T, E> {
           match self.inner.poll().expect("cannot poll CpuFuture twice") {
               Async::Ready(Ok(Ok(e))) => Ok(e.into()),
               Async::Ready(Ok(Err(e))) => Err(e),
               Async::Ready(Err(e)) => panic::resume_unwind(e),
               Async::NotReady => Ok(Async::NotReady),
           }
       }
    }


    /// future lib 库的 代码 -----------------------------------------------------
    /// Creates a new future which will eventually be the same as the one created
    /// by the closure provided.
    ///
    /// The provided closure is only run once the future has a callback scheduled
    /// on it, otherwise the callback never runs. Once run, however, this future is
    /// the same as the one the closure creates.
    ///
    /// # Examples
    ///
    /// ```
    /// use futures::future::*;
    ///
    /// let a = lazy(|| ok::<u32, u32>(1));
    ///
    /// let b = lazy(|| -> FutureResult<u32, u32> {
    ///     panic!("oh no!")
    /// });
    /// drop(b); // closure is never run
    /// ```
    pub fn lazy<F, R>(f: F) -> Lazy<F, R>
    where F: FnOnce() -> R,
          R: IntoFuture
    {
        Lazy {
            inner: _Lazy::First(f),
        }
    }

    /// A future which defers creation of the actual future until a callback is
    /// scheduled.
    ///
    /// This is created by the `lazy` function.
    #[derive(Debug)]
        #[must_use = "futures do nothing unless polled"]
    pub struct Lazy<F, R: IntoFuture> {
        inner: _Lazy<F, R::Future>,
    }

    #[derive(Debug)]
    enum _Lazy<F, R> {
        First(F),
        Second(R),
        Moved,
    }

  // futures-0.1.17/src/task_impl/mod.rs
  pub fn spawn<T>(obj: T) -> Spawn<T> {
      Spawn {
          id: fresh_task_id(),
          obj: obj,
          data: local_map(),
      }
  }


impl<F: Future> Spawn<F> {
    /// Polls the internal future, scheduling notifications to be sent to the
    /// `unpark` argument.
    ///
    /// This method will poll the internal future, testing if it's completed
    /// yet. The `unpark` argument is used as a sink for notifications sent to
    /// this future. That is, while the future is being polled, any call to
    /// `task::park()` will return a handle that contains the `unpark`
    /// specified.
    ///
    /// If this function returns `NotReady`, then the `unpark` should have been
    /// scheduled to receive a notification when poll can be called again.
    /// Otherwise if `Ready` or `Err` is returned, the `Spawn` task can be
    /// safely destroyed.
    #[deprecated(note = "recommended to use `poll_future_notify` instead")]
    #[allow(deprecated)]
    pub fn poll_future(&mut self, unpark: Arc<Unpark>) -> Poll<F::Item, F::Error> {
        self.enter(BorrowedUnpark::Old(&unpark), |f| f.poll())
    }

    /// Waits for the internal future to complete, blocking this thread's
    /// execution until it does.
    ///
    /// This function will call `poll_future` in a loop, waiting for the future
    /// to complete. When a future cannot make progress it will use
    /// `thread::park` to block the current thread.
    pub fn wait_future(&mut self) -> Result<F::Item, F::Error> {
        ThreadNotify::with_current(|notify| {

            loop {
                match self.poll_future_notify(notify, 0)? {
                    Async::NotReady => notify.park(),
                    Async::Ready(e) => return Ok(e),
                }
            }
        })
    }

    /// A specialized function to request running a future to completion on the
    /// specified executor.
    ///
    /// This function only works for futures whose item and error types are `()`
    /// and also implement the `Send` and `'static` bounds. This will submit
    /// units of work (instances of `Run`) to the `exec` argument provided
    /// necessary to drive the future to completion.
    ///
    /// When the future would block, it's arranged that when the future is again
    /// ready it will submit another unit of work to the `exec` provided. This
    /// will happen in a loop until the future has completed.
    ///
    /// This method is not appropriate for all futures, and other kinds of
    /// executors typically provide a similar function with perhaps relaxed
    /// bounds as well.
    ///
    /// Note that this method is likely to be deprecated in favor of the
    /// `futures::Executor` trait and `execute` method, but if this'd cause
    /// difficulty for you please let us know!
    pub fn execute(self, exec: Arc<Executor>)
        where F: Future<Item=(), Error=()> + Send + 'static,
    {
        exec.clone().execute(Run { /// 这里最终将 调用  Inner impl Executor 测 方法， 即tx.send
            // Ideally this method would be defined directly on
            // `Spawn<BoxFuture<(), ()>>` so we wouldn't have to box here and
            // it'd be more explicit, but unfortunately that currently has a
            // link error on nightly: rust-lang/rust#36155
            spawn: spawn(Box::new(self.into_inner())),
            inner: Arc::new(RunInner {
                exec: exec,
                mutex: UnparkMutex::new()
            }),
        })
    }
}