Set of extensions and methods that make rust a little easier to use for day to day tasks, as well as big projects.
There are also convenience methods, which are sometimes a bit easier to remember, or at the very least require less typing.
Primary goal is to be useful.
Saving time, or a few characters on things we do hundreds of times a day, adds up.
Or making things easier to read makes debugging and understanding code much faster.
Secondary goals: - Minimize imports - Minimal build time
If you would like to suggest things that make rust a bit easier to use, you can submit a PR.
Include: use easier::prelude::*;
Read lines one by one from file. Note, this makes the assumption that you can read from the file, and will panic if it cannot read from file, or file does no exist. This makes just quickly reading lines way simpler, but is less rusty, as we are not passing errors to caller.
easier:
rust
for line in lines("/tmp/file.txt"){
println!("{line}");
}
instead of:
```rust
//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"), }
```
Use this on iterators instead of .collect::<Vec<_>>()
easier:
rust
let a= [1,2,3].iter().map(|a|a*2).to_vec();
instead of:
rust
let a= [1,2,3].iter().map(|a|a*2).collect::<Vec<_>>();
### into_vec() for items that impl IntoIterator
Use this on items that impl IntoIterator instead of .into_iter().collect::<Vec<_>>()
easier:
rust
let b = HashSet::<u8>::from_iter([1,2,3]).into_vec();
instead of:
rust
let a = HashSet::<u8>::from_iter([1,2,3]).into_iter().collect::<Vec<_>>();
### any()
Instead of !vec.is_empty() use .any() which is easier to read and type.
Can be used on slices, vecs
easier:
rust
if vec.any(){
//do something
}
instead of:
rust
if !vec.is_empty(){
//do something
}
### convert
This converts between types as long as there is a try_from
This should cover many std types
easier:
rust
use easier::prelude::*;
let a: Vec<f64> = [1i32, 2,3].convert().unwrap();
let b: Vec<i32> = vec![0i8].convert().unwrap();
or convert any errors to the default value with:
rust
let a = [1u32, 2, 3].convert_default::<f64>();
or convert any errors to the given value with:
rust
let a:Vec<f64> = [1u32, 2, 3].convert_or(0.0);