Merge branch 'master' of github.com:rustcc/RustPrimer

Author: wayslog

03-editors/03-02-vim.md

@@ -76,26 +76,36 @@ let g:racer_cmd = "<path-to-racer>/target/release/racer"
 let $RUST_SRC_PATH="<path-to-rust-srcdir>/src/"
 ```
 
+#### 使用 YouCompleteMe
+
+YouCompleteMe 是 Vim 下的智能补全插件, 支持 C-family, Python, Rust 等的语法补全, 整合了多种插件, 功能强大. Linux 各发行版的官方源里基本都有软件包, 可直接安装. 如果有需要进行编译安装的话, 可参考[官方教程](https://github.com/Valloric/YouCompleteMe#installation)
+
+让 YCM 支持 Rust 需要在安装 YCM 过程中执行 ./install.py 时加上 --racer-completer, 并在 .vimrc 中添加如下设置
+```
+let g:ycm_rust_src_path="<path-to-rust-srcdir>/src/"
+"" 一些方便的快捷键
+""" 在 Normal 模式下, 敲 <leader>jd 跳转到定义或声明(支持跨文件)
+nnoremap <leader>jd :YcmCompleter GoToDefinitionElseDeclaration<CR>
+""" 在 Insert 模式下, 敲 <leader>; 补全
+inoremap <leader>; <C-x><C-o>
+```
+
 ## 1.3.1 总结
 
-经过不多的配置，我们的到了包括如下功能：
+经过不多的配置，我们得到了如下功能：
 
-  1. 基本的c-x c-o补全
+  1. 基本的c-x c-o补全 (使用 YCM 后, 能做到自动补全)
   2. 语法着色
-  3. gd跳转到定义（不好用）
+  3. gd跳转到定义
 
 总体来看支持度并不高。
 
 ![此处应该有第二张截图](../image/03-editor-vim-welldone.png)
 
 ### 1.3.1 额外的
-Q1. 为什么没有自动补全
-
-A1. 事实上我是一直在用YCM来进行补全的，但是racer并没有被YCM支持，而且似乎有人去YCM下提ISSUE，但是被作者拒绝了，于是就呵呵了。
-
-Q2. 颜色好搓
+Q1. 颜色好搓
 
-A2. 我推荐一个配色，也是我自己用的 [molokai](https://github.com/tomasr/molokai)
+A1. 我推荐一个配色，也是我自己用的 [molokai](https://github.com/tomasr/molokai)
 
 更详细内容可以参见我的[vimrc配置](https://github.com/wayslog/dotfiles/blob/master/_vimrc)，当然，我这个用的是比较老的版本的vundle，仅供参考。
 

06-flow/06-01-comment.md

@@ -10,7 +10,7 @@ Rust 代码文件中，通常我们可以看到 3 种注释。
 
 使用 `//` 进行行注释。
 
-```
+```rust
 // 创建一个绑定
 let x = 5;
 
@@ -21,22 +21,23 @@ let y = 6; // 创建另一个绑定
 
 文档注释使用 ```///```，一般用于函数或结构体（字段）的说明，置于要说明的对象上方。文档注释内部可使用markdown格式的标记语法，可用于 rustdoc 工具的自动文档提取。
 
-    /// Adds one to the number given.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let five = 5;
-    ///
-    /// assert_eq!(6, add_one(5));
-    /// # fn add_one(x: i32) -> i32 {
-    /// #     x + 1
-    /// # }
-    /// ```
-    fn add_one(x: i32) -> i32 {
-        x + 1
-    }
-
+```rust
+/// Adds one to the number given.
+///
+/// # Examples
+///
+/// ```
+/// let five = 5;
+///
+/// assert_eq!(6, add_one(5));
+/// # fn add_one(x: i32) -> i32 {
+/// #     x + 1
+/// # }
+/// ```
+fn add_one(x: i32) -> i32 {
+    x + 1
+}
+```
 
 ## 模块注释
 

06-flow/06-02-condition.md

@@ -8,29 +8,29 @@
 
 Rust 中的 if 表达式基本就是如下几种形式：
 
-```
+```rust
 // 形式 1
 if expr1 {
 
 }
- 
+
 // 形式 2
 if expr1 {
 
 }
 else {
-    
+
 }
 
 // 形式 3
 if expr1 {
-    
+
 }
 else if expr2 {
     // else if 可多重
 }
 else {
-    
+
 }
 
 ```
@@ -42,7 +42,7 @@ else {
 
 鉴于上述第二点，因为是表达式，所以我们可以写出如下代码：
 
-```
+```rust
 let x = 5;
 
 let y = if x == 5 {
@@ -54,17 +54,17 @@ let y = if x == 5 {
 
 或者压缩成一行：
 
-```
+```rust
 let x = 5;
 
 let y = if x == 5 { 10 } else { 15 }; // y: i32
 ```
 
-## if let 
+## if let
 
 我们在代码中常常会看到 `if let` 成对出现，这实际上是一个 match 的简化用法。直接举例来说明：
 
-```
+```rust
 let x = Some(5);
 
 if let Some(y) = x {
@@ -76,14 +76,14 @@ let z = if let Some(y) = x {
 }
 else {
     0
-}
+};
 // z 值为 5    
 
 ```
 
-上面代码等价于 
+上面代码等价于
 
-```
+```rust
 let x = Some(5);
 match x {
     Some(y) => println!("{}", y),
@@ -93,7 +93,7 @@ match x {
 let z = match x {
     Some(y) => y,
     None => 0
-}
+};
 ```
 
 设计这个语法的目的是，在条件判断的时候，直接做一次模式匹配，方便代码书写，使代码更紧凑。
@@ -104,7 +104,7 @@ Rust 中没有类似于 C 的 `switch` 关键字，但它有用于模式匹配
 
 match 的使用非常简单，举例如下：
 
-```
+```rust
 let x = 5;
 
 match x {
@@ -119,4 +119,3 @@ match x {
 }
 ```
 注意，match 也是一个表达式。match 后面会专门论述，请参见 **模式匹配** 这一章。
-

06-flow/06-03-repeatition.md

@@ -10,15 +10,15 @@
 ## for
 
 for 语句用于遍历一个迭代器。
-```
+```rust
 for var in iterator {
     code
 }
 ```
 Rust 迭代器返回一系列的元素，每个元素是循环中的一次重复。然后它的值与 var 绑定，它在循环体中有效。每当循环体执行完后，我们从迭代器中取出下一个值，然后我们再重复一遍。当迭代器中不再有值时，for 循环结束。
 
 比如：
-```
+```rust
 for x in 0..10 {
     println!("{}", x); // x: i32
 }
@@ -39,7 +39,7 @@ for x in 0..10 {
 
 不熟悉迭代器概念的同学可能傻眼了，下面不仿用 C 形式的 for 语句做下对比：
 
-```
+```rust
 // C 语言的 for 循环例子
 for (x = 0; x < 10; x++) {
     printf( "%d\n", x );
@@ -57,7 +57,7 @@ for 语句就是迭代器遍历的语法糖。
 
 上述迭代器的形式虽好，但是好像在循环过程中，少了索引信息。Rust 考虑到了这一点，当你需要记录你已经循环了多少次了的时候，你可以使用 `.enumerate()` 函数。比如：
 
-```
+```rust
 for (i,j) in (5..10).enumerate() {
     println!("i = {} and j = {}", i, j);
 }
@@ -73,7 +73,7 @@ i = 4 and j = 9
 ```
 再比如：
 
-```
+```rust
 let lines = "Content of line one\nContent of line two\nContent of line three\nContent of line four".lines();
 for (linenumber, line) in lines.enumerate() {
     println!("{}: {}", linenumber, line);
@@ -93,15 +93,15 @@ for (linenumber, line) in lines.enumerate() {
 
 Rust 提供了 while 语句，条件表达式为真时，执行语句体。当你不确定应该循环多少次时可选择 while。
 
-```
+```rust
 while expression {
     code
 }
 ```
 
 比如：
 
-```
+```rust
 let mut x = 5; // mut x: i32
 let mut done = false; // mut done: bool
 
@@ -120,15 +120,15 @@ while !done {
 
 有一种情况，我们经常会遇到，就是写一个无限循环：
 
-```
+```rust
 while true {
     // do something    
 }
 ```
 
 针对这种情况，Rust 专门优化提供了一个语句 loop。
 
-```
+```rust
 loop {
     // do something
 }
@@ -138,7 +138,7 @@ loop {
 
 比如说，如下代码：
 
-```
+```rust
 let mut a;
 loop {
      a = 1;
@@ -158,7 +158,7 @@ do_something(a)
 
 像上面那个 while 例子：
 
-```
+```rust
 let mut x = 5;
 let mut done = false;
 
@@ -174,7 +174,7 @@ while !done {
 ```
 可以优化成：
 
-```
+```rust
 let mut x = 5;
 
 loop {
@@ -189,7 +189,7 @@ loop {
 
 下面这个例子演示 continue 的用法：
 
-```
+```rust
 for x in 0..10 {
     if x % 2 == 0 { continue; }
 
@@ -212,7 +212,7 @@ for x in 0..10 {
 
 如下代码只会在 x 和 y 都为奇数时打印他们：
 
-```
+```rust
 'outer: for x in 0..10 {
     'inner: for y in 0..10 {
         if x % 2 == 0 { continue 'outer; } // continues the loop over x
@@ -221,4 +221,3 @@ for x in 0..10 {
     }
 }
 ```
-