mirl 9.2.0

Miners Rust Lib - A massive collection of ever growing and changing functions, structs, and enums. Check the description for compatibility and toggleable features! (Most of the lib is controlled by flags/features so the lib can continue to be lightweight despite its size)
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

#![allow(missing_docs)]
use core::ops::{Add, Div, Mul, Sub};
pub const trait TupleOps<Rhs = Self> {
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
    fn sub(self, rhs: Rhs) -> Self::Output;
    fn mul(self, rhs: Rhs) -> Self::Output;
    fn div(self, rhs: Rhs) -> Self::Output;
}
macro_rules! tuple_ops {
    ( $($n:tt),+ ) => {
        impl<T> const TupleOps for ( $( impl_helper!(@type $n T), )+ )
        where
            T: [const] Add<Output = T>
                + [const] Sub<Output = T>
                + [const] Mul<Output = T>
                + [const] Div<Output = T>
                + Copy
        {
            type Output = ( $( impl_helper!(@type $n T), )+ );

            fn add(self, rhs: Self) -> Self::Output {
                ( $( self.$n + rhs.$n, )+ )
            }

            fn sub(self, rhs: Self) -> Self::Output {
                ( $( self.$n - rhs.$n, )+ )
            }

            fn mul(self, rhs: Self) -> Self::Output {
                ( $( self.$n * rhs.$n, )+ )
            }

            fn div(self, rhs: Self) -> Self::Output {
                ( $( self.$n / rhs.$n, )+ )
            }
        }
    };
}
macro_rules! impl_helper {
    (@type $_:tt$t:ty) => {
        $t
    };
}
tuple_ops! {0,1}
tuple_ops! {0,1,2}
tuple_ops! {0,1,2,3}
tuple_ops! {0,1,2,3,4}
tuple_ops! {0,1,2,3,4,5}
tuple_ops! {0,1,2,3,4,5,6}
tuple_ops! {0,1,2,3,4,5,6,7}
tuple_ops! {0,1,2,3,4,5,6,7,8}
tuple_ops! {0,1,2,3,4,5,6,7,8,9}
tuple_ops! {0,1,2,3,4,5,6,7,8,9,10}
tuple_ops! {0,1,2,3,4,5,6,7,8,9,10,11}