rename lib name

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
-name = "ruf"
+name = "rufl"
 version = "0.1.1"
 authors = ["[email protected]"]
 edition = "2021"
 description = "A powerful util function library for rust"
 license = "MIT"
-repository = "https://github.com/duke-git/ruf"
+repository = "https://github.com/duke-git/rufl"
 keywords = ["rust", "util", "lib", "function", "common"]
 categories = ["utils"]
 

README.md

@@ -3,9 +3,9 @@
 <br/>
 </div>
 
-#### Ruf is an util function library for rust. It provides a series of useful functions to make your rust development easier.
+#### Rufl is an util function library for rust. It provides a series of useful functions to make your rust development easier.
 
-_Ruf is short for "rust util function"._
+_Ruf is short for "rust util function library"._
 
 ## [简体中文](./README_zh-CN.md)
 
@@ -25,11 +25,11 @@ ruf = "0.1.1"
 
 ## Example
 
-Here takes the string function `add_commas` (Add comma to a number value by every 3 numbers from right. Ahead by prefix symbol.) as an example, and the `ruf::string` mod needs to be used.
+Here takes the string function `add_commas` (Add comma to a number value by every 3 numbers from right. Ahead by prefix symbol.) as an example, and the `rufl::string` mod needs to be used.
 
 Code:
 ```rust
-use ruf::string;
+use rufl::string;
 
 fn main() {
     let money_amount: String = string::add_commas("1234567", "$");

README_zh-CN.md

@@ -3,7 +3,7 @@
 <br/>
 </div>
 
-#### Ruf是一个Rust语言工具函数库。它提供了许多工具函数，让你的rust开发变得更简单.
+#### Rufl是一个Rust语言工具函数库。它提供了许多工具函数，让你的rust开发变得更简单.
 
 _Ruf是”rust util function"的缩写。_
 
@@ -25,11 +25,11 @@ ruf = "0.1.1"
 
 ## 示例
 
-这里以字符串函数`add_commas`为例，该函数的作用是每隔3位数（从右边开始）向数字值中添加逗号，并在前面添加前缀符号。为了实现这个功能，我们需要用到 `ruf::string`模块。
+这里以字符串函数`add_commas`为例，该函数的作用是每隔3位数（从右边开始）向数字值中添加逗号，并在前面添加前缀符号。为了实现这个功能，我们需要用到 `rufl::string`模块。
 
 代码:
 ```rust
-use ruf::string;
+use rufl::string;
 
 fn main() {
     let money_amount: String = string::add_commas("1234567", "$");

src/collection/all_match.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(true, collection::all_match(&[1, 2, 3], &|n: &i32, _i: usize| *n <= 3));
 ///

src/collection/chunk.rs

@@ -14,7 +14,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![vec![1, 2], vec![3, 4], vec![5]], collection::chunk(vec![1, 2, 3, 4, 5], 2));
 ///

src/collection/count.rs

@@ -14,7 +14,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(1, collection::count(&[1, 2, 3], 1));
 ///

src/collection/count_by.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(2, collection::count_by([1, 2, 3, 4, 5], &|n: &i32, _i: usize| *n < 3));
 ///

src/collection/difference.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![1], collection::difference([1, 2], [2, 3]));
 ///

src/collection/difference_by.rs

@@ -18,7 +18,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![1.2], collection::difference_by([1.2, 2.1], [2.3, 3.4], &|n: &f64, _i: usize| {n.floor()}));
 ///

src/collection/difference_with.rs

@@ -18,7 +18,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![1, 5], collection::difference_with(vec![1, 2, 3, 4, 5], vec![4, 5, 6, 7, 8], &|n1: i32, n2: i32| { n2 == n1 * 2}));
 ///

src/collection/fill.rs

@@ -13,7 +13,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// let vec1 = vec![0; 5];
 ///

src/collection/filter.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!([1, 2, 3].to_vec(), collection::filter(&[1, 2, 3, 4, 5].to_vec(), &|n: &i32, _i: usize| *n <= 3));
 ///

src/collection/filter_map.rs

@@ -17,7 +17,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(
 ///     [4, 8].to_vec(),

src/collection/find.rs

@@ -18,7 +18,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(Some((4, 3)), collection::find([1, 2, 3, 4, 5], &|n: &i32, _i: usize| *n > 3, 0));
 ///

src/collection/find_last.rs

@@ -18,7 +18,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(Some((4, 3)), collection::find_last([1, 2, 3, 4, 5], &|n: &i32, _i: usize| *n > 3, 3));
 ///

src/collection/index_of.rs

@@ -14,18 +14,18 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(None, collection::index_of(&[1, 2, 3], &0));
 ///
 /// assert_eq!(Some(1), collection::index_of(&[1, 2, 3, 2], &2));
-/// 
+///
 /// ```
 
-pub fn index_of<C: AsRef<[T]>, T: PartialEq+Clone>(collection: &C, item: &T) -> Option<usize> {
+pub fn index_of<C: AsRef<[T]>, T: PartialEq + Clone>(collection: &C, item: &T) -> Option<usize> {
     for (i, v) in collection.as_ref().to_vec().iter().enumerate() {
         if *v == *item {
-            return Some(i)
+            return Some(i);
         }
     }
 

src/collection/insert_at.rs

@@ -6,7 +6,7 @@
 /// * `vec` - The vector to insert.
 ///
 /// * `index` - The position of vector to insert at.
-/// 
+///
 /// * `item` - The element to be inserted.
 ///
 /// # Returns
@@ -16,23 +16,23 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
-/// 
+/// use rufl::collection;
+///
 /// let mut vec = vec!["a", "b", "c"];
-/// 
+///
 /// let result = collection::insert_at(&mut vec, 3, "d");
-/// 
+///
 /// assert_eq!(true, result.ok().unwrap());
 /// assert_eq!(vec!["a", "b", "c", "d"], vec);
-/// 
+///
 /// ```
 
 pub fn insert_at<T>(vec: &mut Vec<T>, index: usize, item: T) -> Result<bool, String> {
     if index > vec.len() {
         return Err(String::from("insert_at: index should be <= vecor length"));
     }
 
-    vec.insert(index, item);  
+    vec.insert(index, item);
 
     Ok(true)
 }
@@ -44,7 +44,7 @@ mod tests {
     #[test]
     fn test_insert_at() {
         let mut vec = vec![];
-        
+
         let result = insert_at(&mut vec, 0, "a");
         assert_eq!(true, result.ok().unwrap());
         assert_eq!(vec!["a"], vec);
@@ -54,7 +54,10 @@ mod tests {
         assert_eq!(vec!["a", "b"], vec);
 
         let result = insert_at(&mut vec, 3, "c");
-        assert_eq!("insert_at: index should be <= vecor length", result.err().unwrap());
+        assert_eq!(
+            "insert_at: index should be <= vecor length",
+            result.err().unwrap()
+        );
         assert_eq!(vec!["a", "b"], vec);
     }
 }

src/collection/intersection.rs

@@ -11,7 +11,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![2, 3], collection::intersection(vec![vec![1, 2, 2, 3], vec![2, 3, 4]]));
 ///

src/collection/is_ascending_order.rs

@@ -11,7 +11,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(true, collection::is_ascending_order(&[1, 2, 3]));
 ///

src/collection/is_descending_order.rs

@@ -11,7 +11,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(false, collection::is_descending_order(&[1, 2, 3]));
 ///

src/collection/is_sorted.rs

@@ -11,7 +11,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(true, collection::is_sorted(&[1, 2, 3]));
 ///

src/collection/last_index_of.rs

@@ -14,7 +14,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(None, collection::last_index_of(&[1, 2, 3], &0));
 ///

src/collection/map.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(vec![2, 3, 4, 5, 6], collection::map(&vec![1, 2, 3, 4, 5], &|n: &i32, _i: usize| { *n + 1 }));
 ///

src/collection/max.rs

@@ -13,7 +13,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(Some(3), collection::max(&vec![1, 2, 3, 2]));
 ///
@@ -23,7 +23,7 @@
 /// ```
 
 pub fn max<C: AsRef<[T]>, T: PartialOrd + Clone>(collection: &C) -> Option<T> {
-    let vector =  collection.as_ref().to_vec();
+    let vector = collection.as_ref().to_vec();
 
     match vector.len() {
         0 => None,
@@ -38,7 +38,7 @@ pub fn max<C: AsRef<[T]>, T: PartialOrd + Clone>(collection: &C) -> Option<T> {
                 // max = cmp::max(max, vector[i])
             }
 
-            return Some(max.clone())
+            return Some(max.clone());
         }
     }
 }

src/collection/min.rs

@@ -13,7 +13,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(Some(1), collection::min(&vec![1, 2, 3, 2]));
 ///
@@ -23,7 +23,7 @@
 /// ```
 
 pub fn min<C: AsRef<[T]>, T: PartialOrd + Clone>(collection: &C) -> Option<T> {
-    let vector =  collection.as_ref().to_vec();
+    let vector = collection.as_ref().to_vec();
 
     match vector.len() {
         0 => None,
@@ -37,7 +37,7 @@ pub fn min<C: AsRef<[T]>, T: PartialOrd + Clone>(collection: &C) -> Option<T> {
                 }
             }
 
-            return Some(min.clone())
+            return Some(min.clone());
         }
     }
 }

src/collection/none_match.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(true, collection::none_match(&[1, 2, 3], &|n: &i32, _i: usize| *n > 3));
 ///

src/collection/partition.rs

@@ -15,7 +15,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!((vec![2, 4], vec![1, 3, 5]), collection::partition(&vec![1, 2, 3, 4, 5], |n: &i32, _i: usize| n % 2 == 0));
 ///

src/collection/reduce.rs

@@ -19,7 +19,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(15, collection::reduce(&vec![1, 2, 3, 4, 5], |x: &i32, y: &i32, i: usize| { x + y }, 0));
 ///

src/collection/reduce_right.rs

@@ -18,7 +18,7 @@
 /// # Examples
 ///
 /// ```
-/// use ruf::collection;
+/// use rufl::collection;
 ///
 /// assert_eq!(9, collection::reduce_right(&vec!["hello", "rust"], |agg, item, _: usize| { agg + item.len() }, 0));
 ///