Expand description
Sugars - Nice macros for better writing
This crate provides a collection of useful macros to make tasks easier.
What it has to offer?
- Macros for
std::collections
: - Macros for
.collect()
comprehensions:- c: Macro to make lazy Iterator collection comprehensions, others below are based on this one.
- cbheap: Macro to
BinaryHeap
collection comprehensions. - cbtmap: Macro to
BTreeMap
“ . - cbtset: Macro to
BTreeSet
“ . - cdeque: Macro to
VecDeque
“ . - cmap: Macro to
HashMap
“ . - cset: Macro to
HashSet
“ . - cvec: Macro to
Vec
“ .
- Smart Pointers:
- Time/Duration:
- Returns a tuple if multiple parameters are given.
- Accepted time patterns are:
min
,sec
,nano
,micro
andmilli
.
Examples
std::collections
Usage of boxed
, same as arc
, cell
, cow
, mutex
and refcell
:
use sugars::boxed;
assert_eq!(Box::new(10), boxed!(10));
Usage of hmap
, same as btmap
:
use std::collections::HashMap;
use sugars::hmap;
let map = hmap! {"1" => 1, "2" => 2, "3" => 3};
let mut map2 = HashMap::new();
map2.insert("1", 1);
map2.insert("2", 2);
map2.insert("3", 3);
assert_eq!(map, map2);
Usage of hset
, same as btset
:
use std::collections::HashSet;
use sugars::hset;
let set = hset! {1, 2, 3};
let mut set2 = HashSet::new();
set2.insert(1);
set2.insert(2);
set2.insert(3);
assert_eq!(set, set2);
Usage of deque
, same as bheap
, lkl
and rlkl
:
use sugars::deque;
use std::collections::VecDeque;
let deque = deque![1, 2, 3];
let mut deque2 = VecDeque::new();
deque2.push_back(1);
deque2.push_back(2);
deque2.push_back(3);
assert_eq!(deque2, deque);
Comprenhensions
Usage of c!
: It follows the syntax: c![<expr>; <<pattern> in <iterator>, >...[, if <condition>]]
.
Note that it generates a lazy Iterator that needs to be dealt with.
use std::collections::HashSet;
use sugars::c;
let vec = c![x; x in 0..10].collect::<Vec<_>>();
let set = c![i*2; &i in vec.iter()].collect::<HashSet<_>>();
// A more complex one
let vec = c![i+j; i in vec.into_iter(), j in set.iter(), if i%2 == 0 && j%2 != 0].collect::<Vec<_>>();
// Or using type hints
let vec: Vec<_> = c![x; x in 0..10].collect();
let set: HashSet<_> = c![i*2; &i in vec.iter()].collect();
let vec: Vec<_> = c![i+j; i in vec.into_iter(), j in set.iter(), if i%2 == 0 && j%2 != 0].collect();
Usage of cvec
, same as cdeque
, clkl
and cbheap
:
use sugars::cvec;
// Normal comprehension
cvec![x; x in 0..10];
// You can filter as well
cvec![x; x in 0..10, if x % 2 == 0];
Usage of cset
, same as cbtset
:
use sugars::cset;
// Normal comprehension
cset! {x; x in 0..10};
// You can filter as well
cset! {x; x in 0..10, if x % 2 == 0};
Usage of cmap
, same as cbtmap
:
use sugars::cmap;
// Normal comprehension
cmap! {x => x*2; x in 1..10};
// You can filter as well
cmap! {x => x*2; x in 1..10, if x % 2 == 0};
Time/Duration:
Usage of dur
and sleep
:
use sugars::{dur, sleep};
let d1 = dur!(10 sec);
let d2 = std::time::Duration::from_secs(10);
assert_eq!(d1, d2);
// Same syntax, but make the thread sleep for the given time
sleep!(10 sec)
Usage of time
:
use sugars::{time, sleep};
// Should print to stderr ≈ 2.0000 seconds
time!( sleep!(2 sec) );
// It also return the evaluated expression, like dbg! macro
let x = time!( 100 + 20 );
Minimal Viable Rust Version
This software requires Rust version equal or above 1.39.0.
LICENSE
This software is licensed under the MIT Public License.
Macros
Create a BinaryHeap
from a list of elements.
Generic lazy iterator comprehensions.
Build BinaryHeap
from collection iterator comprehensions.
Build LinkedList
from collection iterator comprehensions.
Macro that return the hash of what is passed and also can receive
a hasher to use that intead of default HashMap
Hasher.
Create a LinkedList
from a list of elements.
Create a reversed LinkedList
from a list of elements.
Makes a thread sleep a amount following a time pattern.
Print out the time it took to execute a given expression in seconds.