drylib 0.1.23

Rust macro-library for Don't Repeating Yourself
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[macro_export]
macro_rules! lock { // locks given variable whether it's mutex or not
    ($var: expr) => { $var.lock().expect("Failed to lock") };
    ($var: expr, $expect: expr) => { $var.lock().expect($expect) };
    ($var: ident:?) => { $var.lock().expect(&format!("Failed to lock {var}", var = stringify!($var))) };
}

#[macro_export]
macro_rules! parse { // parses one type into another
    ($var: expr, $type: ty) => { $var.parse::<$type>().expect("Failed to parse") };
    ($var: expr, $type: ty, $expect: expr) => { $var.parse::<$type>().expect($expect) };
    ($var: expr, $type: ty:?) => { $var.parse::<$type>().expect(&format!("Failed to parse {t1} into {t2}", t1 = $var, t2 = stringify!($type))) };
}

// am -> Arc Mutex
#[macro_export]
macro_rules! am { // creates Arc<Mutex<`your variable`>>
    ($var: expr) => { std::sync::Arc::new(std::sync::Mutex::new($var)) };
}

#[macro_export]
macro_rules! sleep { // puts thread on sleep
    (i|$t: expr) => { std::thread::sleep(std::time::Duration::from_secs($t as u64)) };
    ($t: expr) => { std::thread::sleep($t) };
}

#[macro_export]
macro_rules! read { // reads input from stdin. 
    // Use std::io::{Write, BufRead, BufReader} for it to work.
    ($msg: expr, $rbuf: expr => $buf: expr) => { // rbuf basically is std::io::BufReader
        print!("{m}", m = $msg); std::io::stdout().flush().unwrap();
        $rbuf.read_line($buf).ok();
    };
    ($rbuf: expr => $buf: expr) => {
        $rbuf.read_line($buf).ok();
    };
    ($buf: expr) => { stdin().read_line($buf).ok() };
}

#[macro_export]
macro_rules! pubstruct { // creates pub struct with optional generic types, optional lifetimes, with all of the fields are public as well.
    ($(#[$meta:meta])*
    $name: ident($(#[$fmeta:meta])* $($t: ty), *)) => {
        $(#[$meta])*
        pub struct $name($(#[$fmeta])* $(pub $t), *);
    };

    ($(#[$meta:meta])*
    $name: ident<$($T: ident), +>($(#[$fmeta:meta])* $($t: ty), *)) => {
        $(#[$meta])*
        pub struct $name<$($T,) *>($(#[$fmeta])* $(pub $t), *);
    };

    ($(#[$meta:meta])*
    $name: ident<$($L: lifetime), +>($(#[$fmeta:meta])* $($t: ty), *)) => {
        $(#[$meta])*
        pub struct $name<$($L,) *>($(#[$fmeta])* $(pub $t), *);
    };

    ($(#[$meta:meta])*
    $name: ident<$($L: lifetime), +, $($T: ident), +>($(#[$fmeta:meta])* $($t: ty), *)) => {
        $(#[$meta])*
        pub struct $name<$($L,) * $($T,) *>($(#[$fmeta])* $(pub $t), *);
    };

    ($(#[$meta:meta])*
    $name: ident {
        $($(#[$fmeta:meta])*
        $field: ident: $t: ty),* $(,)?
    }) => {
        $(#[$meta])*
        pub struct $name {
            $($(#[$fmeta])*
            pub $field: $t),*
        }
    };

    ($(#[$meta:meta])*
    $name: ident<$($T: ident),*> {
        $($(#[$fmeta:meta])*
        $field:ident: $t:ty),* $(,)?
    }) => {
        $(#[$meta])*
        pub struct $name<$($T),*> {
            $($(#[$fmeta])* pub $field: $t),*
        }
    };

    ($(#[$meta:meta])*
    $name: ident<$($L: lifetime),*> {
        $($(#[$fmeta:meta])*
        $field: ident: $t: ty),* $(,)?
    }) => {
        $(#[$meta])*
        pub struct $name<$($L),*> {
            $($(#[$fmeta])* pub $field: $t),*
        }
    };

    ($(#[$meta: meta])*
    $name: ident<$($L: lifetime),*, $($T: ident),*> {
        $($(#[$fmeta: meta])*
        $field: ident: $t: ty),* $(,)?
    }) => {
        $(#[$meta])*
        pub struct $name<$($L),*, $($T),*> {
            $($(#[$fmeta])* pub $field: $t),*
        }
    };
}

#[macro_export]
macro_rules! colored {
    (pr | $($args: tt), *) => { // pr -> print red 
        println!("\x1b[31m{}\x1b[0m", format_args!($($args)*))
    };
    (fr | $($args: tt), *) => { // fr -> format red
        format!("\x1b[31m{}\x1b[0m", format_args!($($args)*))
    };
    (pg | $($args: tt), *) => { // pg -> print gray 
        println!("\x1b[90m{}\x1b[0m", format_args!($($args)*))
    };
    (fg | $($args: tt), *) => { // fg -> format gray
        format!("\x1b[90m{}\x1b[0m", format_args!($($args)*))
    };
}