更简单

使 Rust 更简单！

一系列扩展和方法，使 Rust 在日常任务以及大型项目中使用起来更加简单。
还有一些方便的方法，有时更容易记住，或者至少需要更少的输入。

主要目标是 有用，节省时间或使事物更容易理解。

以下是一些功能示例。主要功能

• group_by —— std 中缺少的迭代器功能
• sort 和 sort_by —— std 中缺少的迭代器功能
• to_vec —— 对迭代器的改进，使代码更易读
• 使用简单语法从文件中读取行
• act 和 act_mut —— 对项目执行操作并继续迭代链

示例

包含：use easier::prelude::*;

lines(path)

逐行读取文件中的行。注意，这假设您可以读取文件，如果无法读取文件或文件不存在，则将引发恐慌。这使得快速读取行更加简单，但不如 Rusty，因为我们没有将错误传递给调用者。

更简单

for line in lines("/tmp/file.txt"){
    println!("{line}");
}

而不是

//Or can also use ? 
 for line in BufReader::new(File::open(&path).unwrap()).lines() {
            let line = line.unwrap();
            println!("{line}");
        }

//Or more fully...
  let file = File::open(&path);
        match file {
            Ok(file) => {
                for line in BufReader::new(file).lines() {
                    match line {
                        Ok(line) => println!("{line}"),
                        Err(_) => panic!("Error"),
                    }
                }
            }
            Err(_) => panic!("Error"),
        }

迭代器的 to_vec()

在迭代器上使用此功能，而不是 .collect::<Vec<_>>()
更简单

let a= [1,2,3].iter().map(|a|a*2).to_vec();

而不是

let a= [1,2,3].iter().map(|a|a*2).collect::<Vec<_>>();

items that impl IntoIterator 的 into_vec()

在实现 IntoIterator 的项上使用此功能，而不是 .into_iter().collect::<Vec<_>>() 更简单

let b = HashSet::<u8>::from_iter([1,2,3]).into_vec();

而不是

let a = HashSet::<u8>::from_iter([1,2,3]).into_iter().collect::<Vec<_>>();

any()

使用 !vec.is_empty() 的替代方案是使用更易于阅读和输入的 .any()。它可以用于切片和向量。

更简单

if vec.any(){
   //do something
}

而不是

if !vec.is_empty(){
   //do something
}

转换

只要存在 try_from，就可以在类型之间进行转换。这应该涵盖了大多数标准类型。
更简单

use easier::prelude::*;
let a: Vec<f64> = [1i32, 2,3].convert().unwrap();
let b: Vec<i32> = vec![0i8].convert().unwrap();

或者使用以下方法将任何错误转换为默认值：

  let a = [1u32, 2, 3].convert_default::<f64>();

或者使用以下方法将任何错误转换为指定的值：

  let a:Vec<f64> = [1u32, 2, 3].convert_or(0.0);

字符串

将字符串切片数组转换为字符串数组。

更简单

let a= ["a","b","c"].strings();

而不是

  let a= ["a","b","c"].iter().map(|a|a.to_string()).collect::<Vec<_>>();
  //or
  let a=["a".to_string(),"b".to_string(),"c".to_string()].into_iter().collect::<Vec<_>>();

group_by 和 group_by_map

按键分组，并返回包含项目的哈希表。

更简单

 let vec = vec![1, 1, 2, 3, 3, 1];
 let map = vec.group_by(|a| *a);
 assert_eq!(map.len(), 3);
 assert_eq!(map.get(&1).unwrap(), &vec![1, 1, 1]);
 assert_eq!(map.get(&2).unwrap(), &vec![2]);
 assert_eq!(map.get(&3).unwrap(), &vec![3, 3]);

//with structs
let persons = vec![
            Person {
                name: "Alice".to_string(),
                age: 20,
            },
            Person {
                name: "Bob".to_string(),
                age: 20,
            },
            Person {
                name: "Charlie".to_string(),
                age: 30,
            },
        ];


let map = persons.iter().group_by(|a| a.age);
assert_eq!(map.len(), 2);


let map = persons.iter().group_by_map(|a| a.age, |a| a.name.as_str());
assert_eq!(map.get(&30).unwrap().first().unwrap(), &"Charlie");

act 和 act_mut 在迭代器上操作

对项目执行操作，并继续迭代器链。它返回自身

更简单

let sum = vec![1, 2, 3].act(|a| println!("{}", a)).sum::<i32>();
let sorted = vec![3, 2, 1].act_mut(|a| a.sort());

sort 和 sort_by 在迭代器上操作

排序可迭代对象，并更轻松地继续链

let vec = vec![3, 2, 1];
let sorted_and_filtered = vec.iter().sort().filter(|a| a > &&1).to_vec();

而不是

let vec = vec![3, 2, 1];
let mut sorted = vec.iter().collect::<Vec<_>>();
sorted.sort();
let filtered = sorted.into_iter().filter(|a| a > &&1).collect::<Vec<_>>();

sort_by

 let sorted=vec![4., 1., 3., 5., 2.].into_iter().sort_by(|a, b| a.partial_cmp(b).unwrap()).to_vec();