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:
  • 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.

1. Returns a tuple if multiple parameters are given.
2. 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 );

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 Arc.
bheap	Create a BinaryHeap from a list of elements.
boxed	Create a new Box.
btmap	Create a BTreeMap from a list of key-value pairs.
btset	Create a BTreeSet from a list of elements.
c	Generic lazy iterator comprehensions.
cbheap	Build BinaryHeap from collection iterator comprehensions.
cbtmap	Build BTreeMap from collection iterator comprehensions.
cbtset	Build BTreeSet from collection iterator comprehensions.
cdeque	Build VecDeque from collection iterator comprehensions.
cell	Create a new Cell.
clkl	Build LinkedList from collection iterator comprehensions.
cmap	Build HashMap from collection iterator comprehensions.
cow	Create new Cow type.
cset	Build HashSet from collection iterator comprehensions.
cvec	Build Vec from collection iterator comprehensions.
deque	Create a VecDeque from a list of elements.
dur	Creates a Duration object following a time pattern.
hash	Macro that return the hash of what is passed and also can receive a hasher to use that intead of default HashMap Hasher.
hmap	Create a HashMap from a list of key-value pairs.
hset	Create a HashSet from a list of elements.
lkl	Create a LinkedList from a list of elements.
mutex	Create a new Mutex.
rc	Create a new Rc.
refcell	Create a new RefCell.
rlkl	Create a reversed LinkedList from a list of elements.
rwlock	Create a new RwLock.
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.