fix: change 、to .

en/src/functional-programing/closure.md

@@ -41,7 +41,7 @@ Closures can capture variables by borrowing or moving. But they prefer to captur
 - by mutable reference: `&mut T`
 - by value: `T`
 
-1、🌟
+1. 🌟
 ```rust,editable
 /* Make it work with least changing */
 fn main() {
@@ -60,7 +60,7 @@ fn main() {
 }
 ```
 
-2、🌟🌟
+2. 🌟🌟
 ```rust,editable
 /* Make it work 
 - Dont use `_reborrow` and `_count_reborrowed`
@@ -89,7 +89,7 @@ fn main() {
 }
 ```
 
-3、🌟🌟
+3. 🌟🌟
 ```rust,editable
 /* Make it work in two ways, none of them is to remove `take(movable)` away from the code
 */
@@ -132,7 +132,7 @@ let add_one_v3 = |x|             { x + 1 };
 let add_one_v4 = |x|               x + 1  ;
 ```
 
-4、🌟
+4. 🌟
 ```rust,editable
 fn main() {
     let example_closure = |x| x;
@@ -151,7 +151,7 @@ When taking a closure as an input parameter, the closure's complete type must be
 - FnMut: the closure uses the captured value by mutable reference (&mut T)
 - FnOnce: the closure uses the captured value by value (T)
 
-5、🌟🌟
+5. 🌟🌟
 ```rust,editable
 /* Make it work by change the trait bound, in two ways*/
 fn fn_once<F>(func: F)
@@ -168,7 +168,7 @@ fn main() {
 }
 ```
 
-6、 🌟🌟
+6. 🌟🌟
 ```rust,editable
 fn main() {
     let mut s = String::new();
@@ -198,7 +198,7 @@ Which trait to use is determined by what the closure does with captured value.
 
 This is because if a move is possible, then any type of borrow should also be possible. Note that the reverse is not true. If the parameter is annotated as `Fn`, then capturing variables by `&mut T` or `T` are not allowed.
 
-7、🌟🌟
+7. 🌟🌟
 ```rust,editable
 /* Fill in the blank */
 
@@ -285,7 +285,7 @@ fn exec<F: Fn()>(f: F)  {
 }
 ```
 
-8、🌟🌟
+8. 🌟🌟
 ```rust,editable
 /* Fill in the blank */
 fn main() {
@@ -305,7 +305,7 @@ fn exec<'a, F: __>(mut f: F) {
 ## Input functions
 Since closure maybe used as arguments, you might wonder can we use functions as arguments too? And indeed they can.
 
-9、🌟🌟
+9. 🌟🌟
 ```rust,editable
 
 /* Implement `call_me` to make it work */
@@ -328,7 +328,7 @@ fn main() {
 ## Closure as return types
 Returning a closure is much harder than you may thought of.
 
-10、🌟🌟
+10. 🌟🌟
 ```rust,editable
 /* Fill in the blank using two approches,
  and fix the errror */
@@ -347,7 +347,7 @@ fn main() {
 }
 ```
 
-11、🌟🌟
+11. 🌟🌟
 ```rust,editable
 /* Fill in the blank and fix the error*/
 fn factory(x:i32) -> __ {

en/src/functional-programing/iterator.md

@@ -23,7 +23,7 @@ fn main() {
 }
 ```
 
-1、🌟
+1. 🌟
 ```rust,editable
 /* Refactoring the following code using iterators */
 fn main() {
@@ -34,7 +34,7 @@ fn main() {
 }
 ```
 
-2、 🌟 One of the easiest ways to create an iterator is to use the range notion: `a..b`.
+2. 🌟 One of the easiest ways to create an iterator is to use the range notion: `a..b`.
 ```rust,editable
 /* Fill in the blank */
 fn main() {
@@ -61,7 +61,7 @@ pub trait Iterator {
 
 And we can call the `next` method on iterators directly.
 
-3、🌟🌟
+3. 🌟🌟
 ```rust,editable
 /* Fill the blanks and fix the errors.
 Using two ways if possible */
@@ -83,7 +83,7 @@ In the previous section, we have mentioned that `for` will apply the `into_iter`
 - `iter`, this borrows each element of the collection through each iteration, thus leaving the collection untouched and available for reuse after the loop
 - `iter_mut`, this mutably borrows each element of the collection, allowing for the collection to be modified in place.
 
-4、🌟
+4. 🌟
 ```rust,editable
 /* Make it work */
 fn main() {
@@ -96,7 +96,7 @@ fn main() {
 }
 ```
 
-5、🌟
+5. 🌟
 ```rust,editable
 /* Fill in the blank */
 fn main() {
@@ -113,7 +113,7 @@ fn main() {
 }
 ```
 
-6、🌟🌟
+6. 🌟🌟
 ```rust,editable
 /* Fill in the blank */
 fn main() {
@@ -169,7 +169,7 @@ fn main() {
 }
 ```
 
-7、🌟🌟🌟
+7. 🌟🌟🌟
 ```rust,editable
 struct Fibonacci {
     curr: u32,
@@ -208,7 +208,7 @@ The `Iterator` trait has a number of methods with default implementations provid
 ### Consuming adaptors
 Some of these methods call the method `next`to use up the iterator, so they are called *consuming adaptors*.
 
-8、🌟🌟
+8. 🌟🌟
 ```rust,edtiable
 /* Fill in the blank and fix the errors */
 fn main() {
@@ -229,7 +229,7 @@ fn main() {
 #### collect
 Other than converting a collection into an iterator, we can also `collect` the result values into a collection, `collect` will cosume the iterator.
 
-9、🌟🌟
+9. 🌟🌟
 ```rust,editable
 /* Make it work */
 use std::collections::HashMap;
@@ -253,7 +253,7 @@ Methods allowing you to change one iterator into another iterator are known as *
 
 But because **all iterators are lazy**, you have to call one of the consuming adapers to get results from calls to iterator adapters.
 
-10、🌟🌟
+10. 🌟🌟
 ```rust,editable
 /* Fill in the blanks */
 fn main() {
@@ -265,7 +265,7 @@ fn main() {
 }
 ```
 
-11、🌟🌟
+11. 🌟🌟
 ```rust
 /* Fill in the blanks */
 use std::collections::HashMap;
@@ -281,7 +281,7 @@ fn main() {
 
 #### Using closures in iterator adaptors
 
-12、🌟🌟 
+12. 🌟🌟 
 ```rust
 /* Fill in the blanks */
 #[derive(PartialEq, Debug)]