提高了README的可读性

Author: Natural-selection1

README-CN.md

@@ -202,7 +202,7 @@ let mut result3 = {
                             } else {
                                 (y.clone(), x.clone())
                             }
-                          })
+                        })
                     })
                 })
             })

README.md

@@ -1,19 +1,16 @@
 # better_comprehension
 
-在rust中的集合推导式和迭代器推导式。提供更好的Rust使用体验
+[中文README](https://github.com/Natural-selection1/better-comprehension-in-rust/blob/master/README-CN.md)
 
 Collection comprehension and Iterator comprehension in Rust. And it provides a better experience in Rust.
 
 # Usage
-语法源自[python推导式](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions)。
-本库为Rust标准库中的所有集合类型提供宏，以及基于引用的迭代器
 
 The syntax is derived from [Python's comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions).
 
 This library provides macros for all collection types in the Rust standard library and an Iterator based on references.
 
 ---
-简单示例
 simple example
 ```rust
 let vec_1 = vec!["AB".to_string(), "CD".to_string()];
@@ -22,8 +19,6 @@ assert_eq!(vec, vec!["AB".to_string(), "CD".to_string()]);
 ```
 
 ---
-你也可以在推导式中使用模式
-
 You can also use patterns in it
 ```rust
 struct Person {
@@ -36,16 +31,12 @@ let vec_deque = vec_deque![name.clone() for Person { name, .. } in people];
 assert_eq!(vec_deque, VecDeque::from(["Joe".to_string(), "Bob".to_string()]));
 ```
 ---
-过滤值
-
-filtering values
+filtering values before comprehension
 ```rust
 let linked_list = linked_list![ i*2 for i in 1..=3 if i != 2 ];
 assert_eq!(linked_list, LinkedList::from([2, 6]));
 ```
 ---
-根据条件返回不同的值
-
 return different values based on conditions
 ```rust
 let b_tree_set = b_tree_set!{
@@ -55,8 +46,6 @@ let b_tree_set = b_tree_set!{
 assert_eq!(b_tree_set, BTreeSet::from([1, 13]));
 ```
 ---
-嵌套推导式
-
 nested comprehension
 ```rust
 let binary_heap = binary_heap![
@@ -66,8 +55,6 @@ let binary_heap = binary_heap![
 assert_eq!(binary_heap.into_sorted_vec(), vec![1, 1, 3, 13]);
 ```
 ---
-和python的推导式一样, 本库的for循环是从上到下读取的.
-
 the reading order of the for loop in this library is from top to bottom, just like Python's comprehension.
 ```rust
 let vec = vector![
@@ -76,10 +63,7 @@ let vec = vector![
     for bottom in 4..=6 if bottom+top != 4];
 assert_eq!(vec, vec![(1, 4), (1, 5), (1, 6), (3, 4), (3, 5), (3, 6)]);
 ```
-
-需要注意的是, 由于在rust中, for loop 是消耗所有权的.
-
-所以通常来说, 对于多层循环, 如果你希望原容器被消耗, 你应该写成如下这样:
+---
 
 Note that in Rust, for loops consume ownership.
 So typically, for nested loops, if you want the original container to be consumed, you should write it like this:
@@ -89,28 +73,24 @@ let vec_1 = vec!["ABC".to_string(), "DEF".to_string()];
 let vec_2 = vec!["abc".to_string(), "def".to_string()];
 let vec_3 = vec![123, 456];
 let vec = {
-    // 遮蔽想消耗的变量
     // shadow the variable you want to consume
     let vec_1 = vec_1;
     let vec_3 = vec_3;
 
     let mut vec = vec![];
-    // 在外层循环里, 你可以选择使用iter()保留所有权
-    // In the outer loop, you can choose to use iter() to keep ownership
     for i in vec_1.iter() {
         if i == "ABC" {
-            // 在内层循环里, 你必须使用iter() , 否则所有权会在第一次被转移
             // In the inner loop, you must use iter(),
             // otherwise ownership will be transferred for the first time
             for j in vec_2.iter() {
                 if j == "abc" {
-                    // 如果不使用iter(), 那么vec_3的所有权会在第一次被转移
                     // If you do not use iter(),
-                    // then the ownership of vec_3 will be transferred for the first time
+                    // then the ownership of vec_3
+                    // will be transferred for the first time
                     for k in vec_3.iter() {
                         if k == &123 {
-                            // 仅在必要时使用clone, 以避免不必要的资源浪费
-                            // Only use clone when necessary to avoid unnecessary resource waste
+                            // Only use clone when necessary
+                            // to avoid unnecessary resource waste
                             vec.push((i.clone(), j.clone(), *k));
                         }
                     }
@@ -124,14 +104,14 @@ let vec = {
 println!("{:?}", vec_2); // work well
 // println!("{:?}", vec_3); // borrow of moved value
 ```
+---
+But in this library, you don't need to do this,
 
-但在本库中, 你不需要这么做, 提供的宏会自动帮你处理这些问题.
-
-But in this library, you don't need to do this, the provided macros will automatically handle these problems for you.
+the provided macros will automatically handle these problems for you.
 
-你唯一需要做的就是在你想要保留所有权的变量后面加上.iter() 或 使用 & , 其余会在宏内自动处理.
+You only need to add .iter() or use & before the variable you want to keep ownership,
 
-You only need to add .iter() or use & before the variable you want to keep ownership, the rest will be automatically handled in the macro.
+the rest will be automatically handled in the macro.
 ```rust
 let vec_1 = vec!["ABC".to_string(), "DEF".to_string()];
 let vec_2 = vec!["abc".to_string(), "def".to_string()];
@@ -140,21 +120,21 @@ let vec = vector![
     (i.clone(),j.clone(),*k)
     for i in vec_1 if i == "ABC"
     for j in vec_2.iter() if j == "abc"
-    // for j in &vec_2 if j == "abc" 这种写法也是可以的 this is also reasonable
+    // for j in &vec_2 if j == "abc"  // this is also reasonable
     for k in vec_3 if k == &123
 ];
 // println!("{:?}", vec_1); // borrow of moved value
 println!("{:?}", vec_2); // work well
 // println!("{:?}", vec_3); // borrow of moved value
 ```
-
-同时, 该库还支持键值对容器类型, HashMap, BTreeMap
+---
 This library also supports key-value collection types, HashMap, BTreeMap
 ```rust
 let vec_key = vec!["key_1".to_string(), "key_2".to_string(), "key_3".to_string()];
     let vec_value = [1, 2, 3];
     let hash_map = hash_map!{
-        key.clone() : *value // 三种键值对分隔符都支持
+        // the following three key-value pair separators are supported
+        key.clone() : *value
         // key.clone() => *value
         // key.clone() , *value
         for key in vec_key
@@ -169,13 +149,7 @@ let vec_key = vec!["key_1".to_string(), "key_2".to_string(), "key_3".to_string()
         ])
     );
 ```
-
-该库也支持迭代器推导式, 但不同于上面的集合推导式
-
-该迭代器推导式是基于引用的, 所以不会消耗所有权
-
-除此之外的写法与集合推导式完全相同
-
+---
 Iterator comprehension is also supported,but unlike the collection comprehension above,
 
 this iterator comprehension is based on references,so it will not consume ownership.
@@ -206,7 +180,6 @@ None
 */
 ```
 
-以上写法与下面的写法是完全的等价形式
 
 The above writing is equivalent to the following writing
 ```rust
@@ -216,33 +189,23 @@ let vec_2 = ["ABC".to_string(), "DEF".to_string(), "GHI".to_string()];
 let mut result3 = {
     let vec_2 = vec_2.iter().collect::<Vec<_>>();
     let vec_1 = vec_1.iter().collect::<Vec<_>>();
-    (vec_1)
-        .into_iter()
-        .filter_map(move |x| {
-            (x.contains("1") || x.contains("7"))
-                .then(|| {
+    (vec_1).into_iter().filter_map(move |x| {
+        (x.contains("1") || x.contains("7")).then(|| {
+            let vec_2 = vec_2.clone();
+            (1..=2).into_iter().filter_map(move |i| {
+                (true).then(|| {
                     let vec_2 = vec_2.clone();
-                    (1..=2)
-                        .into_iter()
-                        .filter_map(move |i| {
-                            (true)
-                                .then(|| {
-                                    let vec_2 = vec_2.clone();
-                                    (vec_2)
-                                        .into_iter()
-                                        .filter_map(move |y| {
-                                            (y.contains("D") || x.contains("3"))
-                                                .then(|| {
-                                                    if x.contains("1") {
-                                                        (x.clone(), y.clone())
-                                                    } else {
-                                                        (y.clone(), x.clone())
-                                                    }
-                                                })
-                                        })
-                                })
+                    (vec_2).into_iter().filter_map(move |y| {
+                        (y.contains("D") || x.contains("3")).then(|| {
+                            if x.contains("1") {
+                                (x.clone(), y.clone())
+                            } else {
+                                (y.clone(), x.clone())
+                            }
                         })
+                    })
                 })
+            })
         })
         .flatten()
         .flatten()
@@ -252,50 +215,18 @@ let mut result3 = {
 
 # some details
 
-vector! :
-
-使用push添加元素
-
-use push to add elements
-
-vec_deque! :
-
-使用push_back添加元素
-
-use push_back to add elements
-
-linked_list! :
-
-使用push_back添加元素
-
-use push_back to add elements
-
-hash_set! :
-
-使用insert添加元素
-
-use insert to add elements
-
-hash_map! :
-
-使用insert添加键值对
-
-use insert to add key-value pairs
-
-b_tree_map! :
-
-使用insert添加键值对
+vector! : push() to add elements
 
-use insert to add key-value pairs
+vec_deque! : push_back() to add elements
 
-b_tree_set! :
+linked_list! : push_back() to add elements
 
-使用insert添加元素
+binary_heap! : push() to add elements
 
-use insert to add elements
+hash_set! : insert() to add elements
 
-binary_heap! :
+b_tree_set! : insert() to add elements
 
-使用push添加元素
+hash_map! : insert() to add key-value pairs
 
-use push to add elements
+b_tree_map! : insert() to add key-value pairs