trait_exerci = "0.3.0"

Author: cnruby

docs/zh-first-volumn/src/hello-mod-trait/README.md

@@ -5,46 +5,6 @@
 - 了解和学习动态调度关键词`dyn`
 - 学习和理解动态与静态调度（Static vs Dynamic Dispatch）
 - 衔接类型关键词`trait`作用
-- 
-
-rust没有继承，继承不流行了。通过trait缺省函数和覆盖来重用代码，泛型来实现多态。
-
-rust也通过trait object, 特性对象来实现多态。
-
-特性对象，本质上就是不限类型的，动态的特性绑定，run time匹配具体类型
-
-　　
-You can only make object-safe traits into trait objects.
-您只能将对象安全的特征变成特征对象。
-
-Traits that do not resolve to concrete type of implementation. 
-不能解决具体实现类型的特征。
-
-In practice two rules govern if a trait is object-safe.
-实际上，有两个规则控制特征是否是对象安全的。
-
-The return type isn’t Self.
-There are no generic type parameters.
-返回类型不是Self。
-没有通用类型参数。
-
-
-Any trait satisfying these two rules can be used as trait objects.
-任何东西都可以用作特质对象。
-
-Example of trait that is object-safe can be used as trait object:
-可以将对象安全的特征示例用作特征对象：
-
-trait Draw {
-    fn draw(&self);
-}
-
-Example of trait that cannot be used as trait object:
-不能用作特征对象的特征示例：
-
-trait Draw {
-    fn draw(&self) -> Self;
-}
 
 ## 参考资料
 - [rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf](https://archive.fosdem.org/2018/schedule/event/rust_testing_mocking/attachments/slides/2113/export/events/attachments/rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf)

docs/zh-first-volumn/src/hello-mod-trait/about.md

@@ -29,23 +29,56 @@
 ## 项目目录文件结构
 
 ```bash
-$ tree -L 2
+$ tree -L 3
 .
 ├── Cargo.lock
 ├── Cargo.toml
 ├── README.md
-├── examples
-│   ├── trait_dispatch_abstract.rs
-│   ├── trait_dispatch_concrete.rs
-│   └── trait_where_hello.rs
-└── src
-    ├── lib.rs
-    ├── mod_bare
-    ├── mod_deref.rs
-    ├── mod_deref_fn.rs
-    ├── mod_dynamic_fn.rs
-    ├── mod_generics.rs
-    ├── mod_generics_fn.rs
-    ├── mod_static_fn.rs
-    └── mod_where_fn.rs
+├── bin-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   ├── bin
+│   │   └── main.rs
+│   └── target
+│       └── debug
+├── bin-local-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   └── main.rs
+│   ├── target
+│   │   └── debug
+│   └── tests
+│       └── type_both_hello.rs
+└── lib-hello
+    ├── Cargo.lock
+    ├── Cargo.toml
+    ├── README.md
+    ├── examples
+    │   ├── bare_hello.rs
+    │   ├── box_dynamic_hello.rs
+    │   ├── box_static_hello.rs
+    │   ├── generics_fn_hello.rs
+    │   ├── generics_impl_hello.rs
+    │   ├── generics_trait_hello.rs
+    │   ├── generics_type_hello.rs
+    │   ├── simple_dynamic_dispatch.rs
+    │   ├── simple_static_dispatch.rs
+    │   ├── trait_dispatch_abstract.rs
+    │   ├── trait_dispatch_concrete.rs
+    │   ├── trait_fn_hello.rs
+    │   ├── trait_instance_hello.rs
+    │   └── trait_where_hello.rs
+    ├── src
+    │   ├── lib.rs
+    │   ├── mod_bare
+    │   ├── mod_dynamic_fn.rs
+    │   ├── mod_static_fn.rs
+    │   └── mod_where_fn.rs
+    └── tests
+        ├── box_dynamic_hello.rs
+        ├── box_static_hello.rs
+        ├── mod_bare.rs
+        └── mod_trait.rs
 ```

docs/zh-first-volumn/src/hello-mod-trait/examples-dispatch.md

@@ -41,7 +41,13 @@
 
 　　这里将说明基于衔接特质关键性`trait`的静态和动态函数实现，但是这静态函数与之前的也是完全不一样的概念。另外将会看到调用这种动态函数，它们看起来是一些更复杂的静态和动态函数。
 
-　　 下面程序第二段代码的两个函数`static_dispatch()`和`dynamic_dispatch()`，它们的目的是解决代码重复的相同问题。但是其手段是不同的，静态函数`static_dispatch()`使用了泛型编程方法，关于泛型编程将有另外专题说明。而动态函数`dynamic_dispatch()`使用了动态编程方法。从代码上看，它们达到相同的功能。
+　　下面程序第二段代码的两个函数`static_dispatch()`和`dynamic_dispatch()`，它们的目的是解决代码重复的相同问题。但是其手段是不同的。
+
+　　Rust语言没有继承概念，继承编程不再是软件开发的思想。通过关键词`trait`定义函数，借助于关键词impl实现函数及其泛型编程方法，以实现多态式编程方法。静态函数`static_dispatch()`使用了泛型编程方法，关于泛型编程将有另外专题说明。
+
+　　Rust语言也通过衔接特质对象及动态调度编程方法，来实现多态式编程方法。动态函数`dynamic_dispatch()`使用了动态编程方法。特性对象是不限类型的，动态绑定类型是通过实时运行时具体地匹配类型。
+
+　　从代码上看，静态函数`static_dispatch()`和动态函数`dynamic_dispatch()`都是实现相同的功能。
 
 　　下面程序第三段代码里，无论是类型`NormalStruct`，还是类型`TupleStruct`，它们都是以同一方式分别调用函数`static_dispatch()`和函数`dynamic_dispatch()`。
 

docs/zh-volumn-one/hello-mod-trait/about.html

@@ -173,25 +173,58 @@ <h2><a class="header" href="#软件篋类型清单" id="软件篋类型清单">
 <tr><td>可执行程序</td><td>bin-hello</td><td>./hello-mod-trait/bin-hello</td></tr>
 </tbody></table>
 <h2><a class="header" href="#项目目录文件结构" id="项目目录文件结构">项目目录文件结构</a></h2>
-<pre><code class="language-bash">$ tree -L 2
+<pre><code class="language-bash">$ tree -L 3
 .
 ├── Cargo.lock
 ├── Cargo.toml
 ├── README.md
-├── examples
-│   ├── trait_dispatch_abstract.rs
-│   ├── trait_dispatch_concrete.rs
-│   └── trait_where_hello.rs
-└── src
-    ├── lib.rs
-    ├── mod_bare
-    ├── mod_deref.rs
-    ├── mod_deref_fn.rs
-    ├── mod_dynamic_fn.rs
-    ├── mod_generics.rs
-    ├── mod_generics_fn.rs
-    ├── mod_static_fn.rs
-    └── mod_where_fn.rs
+├── bin-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   ├── bin
+│   │   └── main.rs
+│   └── target
+│       └── debug
+├── bin-local-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   └── main.rs
+│   ├── target
+│   │   └── debug
+│   └── tests
+│       └── type_both_hello.rs
+└── lib-hello
+    ├── Cargo.lock
+    ├── Cargo.toml
+    ├── README.md
+    ├── examples
+    │   ├── bare_hello.rs
+    │   ├── box_dynamic_hello.rs
+    │   ├── box_static_hello.rs
+    │   ├── generics_fn_hello.rs
+    │   ├── generics_impl_hello.rs
+    │   ├── generics_trait_hello.rs
+    │   ├── generics_type_hello.rs
+    │   ├── simple_dynamic_dispatch.rs
+    │   ├── simple_static_dispatch.rs
+    │   ├── trait_dispatch_abstract.rs
+    │   ├── trait_dispatch_concrete.rs
+    │   ├── trait_fn_hello.rs
+    │   ├── trait_instance_hello.rs
+    │   └── trait_where_hello.rs
+    ├── src
+    │   ├── lib.rs
+    │   ├── mod_bare
+    │   ├── mod_dynamic_fn.rs
+    │   ├── mod_static_fn.rs
+    │   └── mod_where_fn.rs
+    └── tests
+        ├── box_dynamic_hello.rs
+        ├── box_static_hello.rs
+        ├── mod_bare.rs
+        └── mod_trait.rs
 </code></pre>
 
                     </main>

docs/zh-volumn-one/hello-mod-trait/examples-dispatch.html

@@ -230,7 +230,10 @@ <h2><a class="header" href="#静态函数的动态调度实例" id="静态函数
 </code></pre></pre>
 <h2><a class="header" href="#调用动态函数的实例" id="调用动态函数的实例">调用动态函数的实例</a></h2>
 <p>　　这里将说明基于衔接特质关键性<code>trait</code>的静态和动态函数实现，但是这静态函数与之前的也是完全不一样的概念。另外将会看到调用这种动态函数，它们看起来是一些更复杂的静态和动态函数。</p>
-<p>　　 下面程序第二段代码的两个函数<code>static_dispatch()</code>和<code>dynamic_dispatch()</code>，它们的目的是解决代码重复的相同问题。但是其手段是不同的，静态函数<code>static_dispatch()</code>使用了泛型编程方法，关于泛型编程将有另外专题说明。而动态函数<code>dynamic_dispatch()</code>使用了动态编程方法。从代码上看，它们达到相同的功能。</p>
+<p>　　下面程序第二段代码的两个函数<code>static_dispatch()</code>和<code>dynamic_dispatch()</code>，它们的目的是解决代码重复的相同问题。但是其手段是不同的。</p>
+<p>　　Rust语言没有继承概念，继承编程不再是软件开发的思想。通过关键词<code>trait</code>定义函数，借助于关键词impl实现函数及其泛型编程方法，以实现多态式编程方法。静态函数<code>static_dispatch()</code>使用了泛型编程方法，关于泛型编程将有另外专题说明。</p>
+<p>　　Rust语言也通过衔接特质对象及动态调度编程方法，来实现多态式编程方法。动态函数<code>dynamic_dispatch()</code>使用了动态编程方法。特性对象是不限类型的，动态绑定类型是通过实时运行时具体地匹配类型。</p>
+<p>　　从代码上看，静态函数<code>static_dispatch()</code>和动态函数<code>dynamic_dispatch()</code>都是实现相同的功能。</p>
 <p>　　下面程序第三段代码里，无论是类型<code>NormalStruct</code>，还是类型<code>TupleStruct</code>，它们都是以同一方式分别调用函数<code>static_dispatch()</code>和函数<code>dynamic_dispatch()</code>。</p>
 <p>　　不管是静态函数，还是动态函数，它们都是基于衔接特质对象的指针实现，这一点是非常重要的。</p>
 <p>　　下面程序是Rust语言非常经典的代码结构。</p>

docs/zh-volumn-one/hello-mod-trait/index.html

@@ -155,34 +155,7 @@ <h2><a class="header" href="#学习内容" id="学习内容">学习内容</a></h
 <li>了解和学习动态调度关键词<code>dyn</code></li>
 <li>学习和理解动态与静态调度（Static vs Dynamic Dispatch）</li>
 <li>衔接类型关键词<code>trait</code>作用</li>
-<li></li>
 </ul>
-<p>rust没有继承，继承不流行了。通过trait缺省函数和覆盖来重用代码，泛型来实现多态。</p>
-<p>rust也通过trait object, 特性对象来实现多态。</p>
-<p>特性对象，本质上就是不限类型的，动态的特性绑定，run time匹配具体类型</p>
-<p>　　
-You can only make object-safe traits into trait objects.
-您只能将对象安全的特征变成特征对象。</p>
-<p>Traits that do not resolve to concrete type of implementation. 
-不能解决具体实现类型的特征。</p>
-<p>In practice two rules govern if a trait is object-safe.
-实际上，有两个规则控制特征是否是对象安全的。</p>
-<p>The return type isn’t Self.
-There are no generic type parameters.
-返回类型不是Self。
-没有通用类型参数。</p>
-<p>Any trait satisfying these two rules can be used as trait objects.
-任何东西都可以用作特质对象。</p>
-<p>Example of trait that is object-safe can be used as trait object:
-可以将对象安全的特征示例用作特征对象：</p>
-<p>trait Draw {
-fn draw(&amp;self);
-}</p>
-<p>Example of trait that cannot be used as trait object:
-不能用作特征对象的特征示例：</p>
-<p>trait Draw {
-fn draw(&amp;self) -&gt; Self;
-}</p>
 <h2><a class="header" href="#参考资料" id="参考资料">参考资料</a></h2>
 <ul>
 <li><a href="https://archive.fosdem.org/2018/schedule/event/rust_testing_mocking/attachments/slides/2113/export/events/attachments/rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf">rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf</a></li>

docs/zh-volumn-one/print.html

@@ -2322,34 +2322,7 @@ <h2><a class="header" href="#学习内容-17" id="学习内容-17">学习内容<
 <li>了解和学习动态调度关键词<code>dyn</code></li>
 <li>学习和理解动态与静态调度（Static vs Dynamic Dispatch）</li>
 <li>衔接类型关键词<code>trait</code>作用</li>
-<li></li>
 </ul>
-<p>rust没有继承，继承不流行了。通过trait缺省函数和覆盖来重用代码，泛型来实现多态。</p>
-<p>rust也通过trait object, 特性对象来实现多态。</p>
-<p>特性对象，本质上就是不限类型的，动态的特性绑定，run time匹配具体类型</p>
-<p>　　
-You can only make object-safe traits into trait objects.
-您只能将对象安全的特征变成特征对象。</p>
-<p>Traits that do not resolve to concrete type of implementation. 
-不能解决具体实现类型的特征。</p>
-<p>In practice two rules govern if a trait is object-safe.
-实际上，有两个规则控制特征是否是对象安全的。</p>
-<p>The return type isn’t Self.
-There are no generic type parameters.
-返回类型不是Self。
-没有通用类型参数。</p>
-<p>Any trait satisfying these two rules can be used as trait objects.
-任何东西都可以用作特质对象。</p>
-<p>Example of trait that is object-safe can be used as trait object:
-可以将对象安全的特征示例用作特征对象：</p>
-<p>trait Draw {
-fn draw(&amp;self);
-}</p>
-<p>Example of trait that cannot be used as trait object:
-不能用作特征对象的特征示例：</p>
-<p>trait Draw {
-fn draw(&amp;self) -&gt; Self;
-}</p>
 <h2><a class="header" href="#参考资料-16" id="参考资料-16">参考资料</a></h2>
 <ul>
 <li><a href="https://archive.fosdem.org/2018/schedule/event/rust_testing_mocking/attachments/slides/2113/export/events/attachments/rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf">rust_testing_mocking/slides/2113/testing_in_rust_by_donald_whyte.pdf</a></li>
@@ -2393,25 +2366,58 @@ <h2><a class="header" href="#软件篋类型清单-2" id="软件篋类型清单-
 <tr><td>可执行程序</td><td>bin-hello</td><td>./hello-mod-trait/bin-hello</td></tr>
 </tbody></table>
 <h2><a class="header" href="#项目目录文件结构" id="项目目录文件结构">项目目录文件结构</a></h2>
-<pre><code class="language-bash">$ tree -L 2
+<pre><code class="language-bash">$ tree -L 3
 .
 ├── Cargo.lock
 ├── Cargo.toml
 ├── README.md
-├── examples
-│   ├── trait_dispatch_abstract.rs
-│   ├── trait_dispatch_concrete.rs
-│   └── trait_where_hello.rs
-└── src
-    ├── lib.rs
-    ├── mod_bare
-    ├── mod_deref.rs
-    ├── mod_deref_fn.rs
-    ├── mod_dynamic_fn.rs
-    ├── mod_generics.rs
-    ├── mod_generics_fn.rs
-    ├── mod_static_fn.rs
-    └── mod_where_fn.rs
+├── bin-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   ├── bin
+│   │   └── main.rs
+│   └── target
+│       └── debug
+├── bin-local-hello
+│   ├── Cargo.lock
+│   ├── Cargo.toml
+│   ├── src
+│   │   └── main.rs
+│   ├── target
+│   │   └── debug
+│   └── tests
+│       └── type_both_hello.rs
+└── lib-hello
+    ├── Cargo.lock
+    ├── Cargo.toml
+    ├── README.md
+    ├── examples
+    │   ├── bare_hello.rs
+    │   ├── box_dynamic_hello.rs
+    │   ├── box_static_hello.rs
+    │   ├── generics_fn_hello.rs
+    │   ├── generics_impl_hello.rs
+    │   ├── generics_trait_hello.rs
+    │   ├── generics_type_hello.rs
+    │   ├── simple_dynamic_dispatch.rs
+    │   ├── simple_static_dispatch.rs
+    │   ├── trait_dispatch_abstract.rs
+    │   ├── trait_dispatch_concrete.rs
+    │   ├── trait_fn_hello.rs
+    │   ├── trait_instance_hello.rs
+    │   └── trait_where_hello.rs
+    ├── src
+    │   ├── lib.rs
+    │   ├── mod_bare
+    │   ├── mod_dynamic_fn.rs
+    │   ├── mod_static_fn.rs
+    │   └── mod_where_fn.rs
+    └── tests
+        ├── box_dynamic_hello.rs
+        ├── box_static_hello.rs
+        ├── mod_bare.rs
+        └── mod_trait.rs
 </code></pre>
 <h1><a class="header" href="#文件与模块" id="文件与模块">文件与模块</a></h1>
 <p>　　在这一节里，学习Cargo项目文件、目录与模块相互关系。Rust语言表达模块的三种方式。</p>
@@ -2760,7 +2766,10 @@ <h2><a class="header" href="#静态函数的动态调度实例" id="静态函数
 </code></pre></pre>
 <h2><a class="header" href="#调用动态函数的实例" id="调用动态函数的实例">调用动态函数的实例</a></h2>
 <p>　　这里将说明基于衔接特质关键性<code>trait</code>的静态和动态函数实现，但是这静态函数与之前的也是完全不一样的概念。另外将会看到调用这种动态函数，它们看起来是一些更复杂的静态和动态函数。</p>
-<p>　　 下面程序第二段代码的两个函数<code>static_dispatch()</code>和<code>dynamic_dispatch()</code>，它们的目的是解决代码重复的相同问题。但是其手段是不同的，静态函数<code>static_dispatch()</code>使用了泛型编程方法，关于泛型编程将有另外专题说明。而动态函数<code>dynamic_dispatch()</code>使用了动态编程方法。从代码上看，它们达到相同的功能。</p>
+<p>　　下面程序第二段代码的两个函数<code>static_dispatch()</code>和<code>dynamic_dispatch()</code>，它们的目的是解决代码重复的相同问题。但是其手段是不同的。</p>
+<p>　　Rust语言没有继承概念，继承编程不再是软件开发的思想。通过关键词<code>trait</code>定义函数，借助于关键词impl实现函数及其泛型编程方法，以实现多态式编程方法。静态函数<code>static_dispatch()</code>使用了泛型编程方法，关于泛型编程将有另外专题说明。</p>
+<p>　　Rust语言也通过衔接特质对象及动态调度编程方法，来实现多态式编程方法。动态函数<code>dynamic_dispatch()</code>使用了动态编程方法。特性对象是不限类型的，动态绑定类型是通过实时运行时具体地匹配类型。</p>
+<p>　　从代码上看，静态函数<code>static_dispatch()</code>和动态函数<code>dynamic_dispatch()</code>都是实现相同的功能。</p>
 <p>　　下面程序第三段代码里，无论是类型<code>NormalStruct</code>，还是类型<code>TupleStruct</code>，它们都是以同一方式分别调用函数<code>static_dispatch()</code>和函数<code>dynamic_dispatch()</code>。</p>
 <p>　　不管是静态函数，还是动态函数，它们都是基于衔接特质对象的指针实现，这一点是非常重要的。</p>
 <p>　　下面程序是Rust语言非常经典的代码结构。</p>