Merge branch 'main' of github.com:sunface/rust-course

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+book

README.md

@@ -30,7 +30,7 @@
 - [Rust Book](https://doc.rust-lang.org/book)
 - [Rust nomicon](https://doc.rust-lang.org/nomicon/dot-operator.html)
 - [Async Rust](https://rust-lang.github.io/async-book/01_getting_started/01_chapter.html)
-- 详细清单参见 [这里](./book/writing-material/books.md)
+- 详细清单参见 [这里](./assets/writing-material/books.md)
 
 因为它们绝大部分是支持 APACHE + MIT 双协议的，因此我们选择了遵循其中的 MIT 协议，并在这里统一对借鉴的书籍进行说明。
 

book.toml

@@ -8,7 +8,7 @@ src = "contents"
 additional-css = ["assets/ferris.css", "assets/theme/2018-edition.css"]
 additional-js = ["assets/ferris.js"]
 git-repository-url = "https://github.com/sunface/rust-course"
-edit-url-template = "https://github.com/sunface/rust-course/edit/main/book/{path}"
+edit-url-template = "https://github.com/sunface/rust-course/edit/main/{path}"
 
 [output.html.playground]
 editable = true

book/.gitignore

@@ -1,2 +0,0 @@
-book
-.DS_Store

book/contents/confonding/string.md

@@ -1 +0,0 @@
-# String、&str 和 str todo

book/contents/test/benchmark.md

@@ -1,65 +0,0 @@
-# 性能测试
-
-https://www.reddit.com/r/rust/comments/sh8u72/why_my_rust_benchmarks_were_wrong_or_how_to/
-
-https://doc.rust-lang.org/unstable-book/library-features/test.html
-
-## benchmark迷一般的性能结果
-代码如下
-```rust
-#![feature(test)]
-
-extern crate test;
-
-fn fibonacci_u64(number: u64) -> u64 {
-    let mut last: u64 = 1;
-    let mut current: u64 = 0;
-    let mut buffer: u64;
-    let mut position: u64 = 1;
-
-    return loop {
-        if position == number {
-            break current;
-        }
-
-        buffer = last;
-        last = current;
-        current = buffer + current; 
-        position += 1;
-    };
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use test::Bencher;
-
-    #[test]
-    fn it_works() {
-       assert_eq!(fibonacci_u64(1), 0); 
-       assert_eq!(fibonacci_u64(2), 1); 
-       assert_eq!(fibonacci_u64(12), 89); 
-       assert_eq!(fibonacci_u64(30), 514229); 
-    }
-
-    #[bench]
-    fn bench_u64(b: &mut Bencher) {
-        b.iter(|| {
-            for i in 100..200 {
-                fibonacci_u64(i);
-            }
-        });
-    }
-}
-```
-通过`cargo bench`运行后，得到一个难以置信的结果：`test tests::bench_u64 ... bench: 0 ns/iter (+/- 0)`, 难道Rust已经到达量子计算机级别了？
-
-其实，原因藏在`LLVM`中: `LLVM`认为`fibonacci_u64`函数调用的结果没有使用，同时也认为该函数没有任何副作用(造成其它的影响，例如修改外部变量、访问网络等), 因此它有理由把这个函数调用优化掉！
-
-解决很简单，使用Rust标准库中的[`black_box`](https://doc.rust-lang.org/std/hint/fn.black_box.html)函数:
-```rust
-for i in 100..200 {
-    black_box(fibonacci_u64(black_box(i)));
-}
-```
-
-通过这个函数，告诉编译器，尽量少的做优化，此时LLVM就不会再自作主张了:)

book/solutions/Readme.md

@@ -1 +0,0 @@
-## Rust语言圣经随书习题的答案

book/solutions/closure.md

@@ -1,51 +0,0 @@
-## 闭包
-
-下面代码是Rust圣经课程中[闭包](http://course.rs/advance/functional-programing/closure.html#结构体中的闭包)章节的课内练习题答案：
-
-```rust
-struct Cacher<T,E>
-where
-    T: Fn(E) -> E,
-    E: Copy
-{
-    query: T,
-    value: Option<E>,
-}
-
-impl<T,E> Cacher<T,E>
-where
-    T: Fn(E) -> E,
-    E: Copy
-{
-    fn new(query: T) -> Cacher<T,E> {
-        Cacher {
-            query,
-            value: None,
-        }
-    }
-
-    fn value(&mut self, arg: E) -> E {
-        match self.value {
-            Some(v) => v,
-            None => {
-                let v = (self.query)(arg);
-                self.value = Some(v);
-                v
-            }
-        }
-    }
-}
-fn main() {
-  
-}
-
-#[test]
-fn call_with_different_values() {
-    let mut c = Cacher::new(|a| a);
-
-    let v1 = c.value(1);
-    let v2 = c.value(2);
-
-    assert_eq!(v2, 1);
-}
-```

contents/SUMMARY.md

@@ -96,7 +96,7 @@
     - [单元测试和集成测试](test/unit-integration-test.md)
     - [断言assertion](test/assertion.md)
     - [用Github Actions进行持续集成](test/ci.md)
-    - [性能基准测试benchmark todo](test/benchmark.md)
+    - [基准测试benchmark](test/benchmark.md)
 
 - [async/await异步编程](async/intro.md)
   - [async编程入门](async/getting-started.md)

contents/advance/functional-programing/closure.md

@@ -287,7 +287,7 @@ where
 }
 ```
 
-上面的缓存有一个很大的问题：只支持 `u32` 类型的值，若我们想要缓存 `String` 类型，显然就行不通了，因此需要将 `u32` 替换成泛型 `E`，该练习就留给读者自己完成，具体代码可以参考[这里](https://github.com/sunface/rust-course/blob/main/book/solutions/closure.md)
+上面的缓存有一个很大的问题：只支持 `u32` 类型的值，若我们想要缓存 `String` 类型，显然就行不通了，因此需要将 `u32` 替换成泛型 `E`，该练习就留给读者自己完成，具体代码可以参考[这里](http://exercise.rs/functional-programming/closure.html)
 
 
 ## 捕获作用域中的值