Crate sugars

source · [−]

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:
- deque: Create VecDeque from list of elements.
- hset: Create HashSet “ .
- btset: Create BTreeSet “ .
- bheap: Create BinaryHeap “ .
- hmap: Create HashMap from key-value pairs.
- btmap: Create BTreeMap “ .
- lkl: Create LinkedList from list of elements.
- rlkl: Create LinkedList, but reversed.
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:
- arc: Create new Arc.¹
- boxed: Create new Box.¹
- cell: Create new Cell.¹
- mutex: Create new Mutex.¹
- refcell: Create new RefCell.¹
- rc: Create new Rc.¹
- rwlock: Create new RwLock.¹
- cow: Create new Cow.
Time/Duration:
- dur: Creates a Duration object following a time pattern.²
- sleep: Makes current thread sleep an amount following a time pattern.²
- time: Print out the time it took to execute a given expression in seconds.

Returns a tuple if multiple parameters are given.
Accepted time patterns are: min, sec, nano, micro and milli.

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 );