batch_oper/macro_lit.rs
1/// new a `Box<T>`
2/// ```
3/// # use batch_oper::*;
4/// # let xxx = 1;
5/// new!(xxx)
6/// # ;
7/// ```
8/// *equivalent to*
9/// ```
10/// # let xxx = 1;
11/// Box::new(xxx)
12/// # ;
13/// ```
14#[macro_export]
15macro_rules! new {
16 () => {
17 Box::new(Default::default())
18 };
19 ($e:expr) => {
20 Box::new($e)
21 };
22}
23
24/// new a `Box<[T]>`
25/// ```
26/// # use batch_oper::*;
27/// # let a = 1; let b = 2; let c = 3;
28/// arr![a, b, c]
29/// # ;
30/// ```
31/// *equivalent to*
32/// ```
33/// # let a = 1; let b = 2; let c = 3;
34/// Box::new([a, b, c])
35/// # ;
36/// ```
37#[macro_export]
38macro_rules! arr {
39 [ $($e:expr),* $(,)? ] => { Box::new([$($e),*]) };
40}
41
42/// new a `VecDeque<T>`
43/// ```
44/// # use batch_oper::*;
45/// # use std::collections::*;
46/// # let a = 1; let b = 2; let c = 3;
47/// deque![a, b, c]
48/// # ;
49/// ```
50/// *equivalent to*
51/// ```
52/// # use std::collections::*;
53/// # let a = 1; let b = 2; let c = 3;
54/// VecDeque::from(vec![a, b, c])
55/// # ;
56/// ```
57#[macro_export]
58macro_rules! deque {
59 [] => { std::collections::VecDeque::new() };
60 [ $elem:expr; $n:expr ] => { std::collections::VecDeque::from(vec![$elem; $n]) };
61 [ $($e:expr),* $(,)? ] => { std::collections::VecDeque::from(vec![$($e),+]) };
62}
63
64/// new a `LinkedList<T>`
65///
66/// ----------
67/// ### Push Back
68/// ```
69/// # use batch_oper::*;
70/// # use std::collections::*;
71/// # let a = 1; let b = 2; let c = 3;
72/// list![a, b, c]
73/// # ;
74/// ```
75/// *equivalent to*
76/// ```
77/// # use std::collections::*;
78/// # let a = 1; let b = 2; let c = 3;
79/// {
80/// let mut l = LinkedList::new();
81/// l.push_back(a);
82/// l.push_back(b);
83/// l.push_back(c);
84/// l
85/// }
86///
87/// # ;
88/// ```
89///
90/// ----------
91/// ### Push Front
92/// ```
93/// # use batch_oper::*;
94/// # use std::collections::*;
95/// # let a = 1; let b = 2; let c = 3;
96/// list![<- a, b, c]
97/// # ;
98/// ```
99/// *equivalent to*
100/// ```
101/// # use std::collections::*;
102/// # let a = 1; let b = 2; let c = 3;
103/// {
104/// let mut l = LinkedList::new();
105/// l.push_front(a);
106/// l.push_front(b);
107/// l.push_front(c);
108/// l
109/// }
110///
111/// # ;
112/// ```
113///
114/// ----------
115/// ### From Elem
116/// ```
117/// # use batch_oper::*;
118/// # use std::collections::*;
119/// # let a = 1;
120/// list![a; 3]
121/// # ;
122/// ```
123/// *equivalent to*
124/// ```
125/// # use std::collections::*;
126/// # let a = 1;
127/// {
128/// let mut l = LinkedList::new();
129/// for _ in 0..3 {
130/// l.push_back(a);
131/// }
132/// l
133/// }
134///
135/// # ;
136/// ```
137#[macro_export]
138macro_rules! list {
139 [] => { std::collections::LinkedList::new() };
140 [ $elem:expr; $n:expr ] => {{
141 let mut l = std::collections::LinkedList::new();
142 for _ in 0..$n {
143 l.push_back($elem);
144 }
145 l
146 }};
147 [ $($e:expr),* $(,)? ] => {{
148 let mut l = std::collections::LinkedList::new();
149 $( l.push_back($e); )*
150 l
151 }};
152 [ <- $($e:expr),* $(,)? ] => {{
153 let mut l = std::collections::LinkedList::new();
154 $( l.push_front($e); )*
155 l
156 }};
157}
158
159/// new a `HashMap<K, V>`
160/// ```
161/// # use batch_oper::*;
162/// # use std::collections::*;
163/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
164/// map! {
165/// ka => va,
166/// kb => vb,
167/// }
168/// # ;
169/// ```
170/// *equivalent to*
171/// ```
172/// # use std::collections::*;
173/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
174/// {
175/// let mut m = HashMap::new();
176/// m.insert(ka, va);
177/// m.insert(kb, vb);
178/// m
179/// }
180/// # ;
181/// ```
182/// ---
183/// map like
184/// ```
185/// # use batch_oper::*;
186/// # use std::collections::*;
187/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
188/// map! { let BTreeMap::new();
189/// ka => va,
190/// kb => vb,
191/// }
192/// # ;
193/// ```
194/// *equivalent to*
195/// ```
196/// # use std::collections::*;
197/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
198/// {
199/// let mut m = BTreeMap::new();
200/// m.insert(ka, va);
201/// m.insert(kb, vb);
202/// m
203/// }
204/// # ;
205/// ```
206#[macro_export]
207macro_rules! map {
208 { } => { std::collections::HashMap::new() };
209 { $($k:expr => $v:expr),* $(,)? } => {{
210 let mut m = std::collections::HashMap::new();
211 $(
212 m.insert($k, $v);
213 )*
214 m
215 }};
216 { let $m:expr; $($k:expr => $v:expr),* $(,)? } => {{
217 let mut m = $m;
218 $(
219 m.insert($k, $v);
220 )*
221 m
222 }};
223}
224
225/// new a `BTreeMap<K, V>`
226/// ```
227/// # use batch_oper::*;
228/// # use std::collections::*;
229/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
230/// btmap! {
231/// ka => va,
232/// kb => vb,
233/// }
234/// # ;
235/// ```
236/// *equivalent to*
237/// ```
238/// # use std::collections::*;
239/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
240/// {
241/// let mut m = BTreeMap::new();
242/// m.insert(ka, va);
243/// m.insert(kb, vb);
244/// m
245/// }
246/// # ;
247/// ```
248#[macro_export]
249macro_rules! btmap {
250 { } => { std::collections::BTreeMap::new() };
251 { $($k:expr => $v:expr),* $(,)? } => {{
252 let mut m = std::collections::BTreeMap::new();
253 $(
254 m.insert($k, $v);
255 )*
256 m
257 }};
258}
259
260/// append items to a map
261/// ```
262/// # use batch_oper::*;
263/// # use std::collections::*;
264/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
265/// let mut m = HashMap::new();
266/// map_append! { m;
267/// ka => va,
268/// kb => vb,
269/// }
270/// # ;
271/// ```
272/// *equivalent to*
273/// ```
274/// # use std::collections::*;
275/// # let ka = 1; let va = 2; let kb = 3; let vb = 4;
276/// let mut m = HashMap::new();
277/// m.insert(ka, va);
278/// m.insert(kb, vb);
279/// # ;
280/// ```
281#[macro_export]
282macro_rules! map_append {
283 { $m:expr; $($k:expr => $v:expr),* $(,)? } => {
284 $(
285 $m.insert($k, $v);
286 )*
287 };
288}
289
290/// new a `HashSet<V>`
291/// ```
292/// # use batch_oper::*;
293/// # use std::collections::*;
294/// # let a = 1; let b = 2;
295/// set![a, b]
296/// # ;
297/// ```
298/// *equivalent to*
299/// ```
300/// # use std::collections::*;
301/// # let a = 1; let b = 2;
302/// {
303/// let mut s = HashSet::new();
304/// s.insert(a);
305/// s.insert(b);
306/// s
307/// }
308/// # ;
309/// ```
310/// ---
311/// set like
312/// ```
313/// # use batch_oper::*;
314/// # use std::collections::*;
315/// # let a = 1; let b = 2;
316/// set![let BTreeSet::new(); 1, 2]
317/// # ;
318/// ```
319/// *equivalent to*
320/// ```
321/// # use std::collections::*;
322/// # let a = 1; let b = 2;
323/// {
324/// let mut s = BTreeSet::new();
325/// s.insert(a);
326/// s.insert(b);
327/// s
328/// }
329/// # ;
330/// ```
331#[macro_export]
332macro_rules! set {
333 { } => { std::collections::HashSet::new() };
334 { $($e:expr),* $(,)? } => {{
335 let mut s = std::collections::HashSet::new();
336 $(
337 s.insert($e);
338 )*
339 s
340 }};
341 { let $s:expr; $($e:expr),* $(,)? } => {{
342 let mut s = $s;
343 $(
344 s.insert($e);
345 )*
346 s
347 }};
348}
349
350/// new a `BTreeSet<V>`
351/// ```
352/// # use batch_oper::*;
353/// # use std::collections::*;
354/// # let a = 1; let b = 2;
355/// btset![a, b]
356/// # ;
357/// ```
358/// *equivalent to*
359/// ```
360/// # use std::collections::*;
361/// # let a = 1; let b = 2;
362/// {
363/// let mut s = BTreeSet::new();
364/// s.insert(a);
365/// s.insert(b);
366/// s
367/// }
368/// # ;
369/// ```
370#[macro_export]
371macro_rules! btset {
372 { } => { std::collections::BTreeSet::new() };
373 { $($e:expr),* $(,)? } => {{
374 let mut s = std::collections::BTreeSet::new();
375 $(
376 s.insert($e);
377 )*
378 s
379 }};
380}
381
382/// new a `BinaryHeap<V>`
383/// ```
384/// # use batch_oper::*;
385/// # use std::collections::*;
386/// # let a = 1; let b = 2;
387/// heap![a, b]
388/// # ;
389/// ```
390/// *equivalent to*
391/// ```
392/// # use std::collections::*;
393/// # let a = 1; let b = 2;
394/// BinaryHeap::from(vec![a, b])
395/// # ;
396/// ```
397#[macro_export]
398macro_rules! heap {
399 [ ] => { std::collections::BinaryHeap::new() };
400 [ $elem:expr; $n:expr ] => { std::collections::BinaryHeap::from(vec![$elem; $n]) };
401 [ $($e:expr),+ $(,)? ] => { std::collections::BinaryHeap::from(vec![$($e),+]) };
402}