[−][src]Crate sugars
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
arc | Create a new |
bheap | Create a |
boxed | Create a new |
btmap | Create a |
btset | Create a |
c | Generic lazy iterator comprehensions. |
cbheap | Build |
cbtmap | Build |
cbtset | Build |
cdeque | Build |
cell | Create a new |
clkl | Build |
cmap | Build |
cow | Create new |
cset | Build |
cvec | Build |
deque | Create a |
dur | Creates a |
hash | Macro that return the hash of what is passed and also can receive
a hasher to use that intead of default |
hmap | Create a |
hset | Create a |
lkl | Create a |
mutex | Create a new |
rc | Create a new |
refcell | Create a new |
rlkl | Create a reversed |
rwlock | Create a new |
sleep | Makes a thread sleep a amount following a time pattern. |
time | Print out the time it took to execute a given expression in seconds. |