ext 0.0.3

A Rust extension library.
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

use crate::no_std::{
    functions::ext::fn_once_ext::FnOnceExt,
    pipelines::{pipe::Pipe, tap::Tap},
};
use minstant::Instant;
use std::{
    fmt::{Debug, Display},
    prelude::v1::*,
    sync::{Arc, Mutex, RwLock},
    time::Duration,
};

/// This trait is to implement some extension functions,
/// which need a generic return type, for any sized type.
pub trait StdAnyExt1<R>: Sized {
    /// Executes the given closure block and returns the duration of elapsed time interval.
    fn ext_measure_time(self, f: impl FnOnce(Self) -> R) -> Duration {
        Instant::now().tap(|_| f(self)).elapsed()
    }

    /// Executes the given closure block,
    /// returns the duration of elapsed time interval and the result of the closure execution.
    fn ext_measure_time_with_value(self, f: impl FnOnce(Self) -> R) -> (Duration, R) {
        Instant::now()
            .pipe(|t| (f(self), t.elapsed()))
            .pipe(|(v, e)| (e, v))
    }

    /// Executes the given closure block,
    /// returns the duration of elapsed time interval and the receiver `self`.
    fn ext_measure_time_with_self(self, f: impl FnOnce(&Self) -> R) -> (Duration, Self) {
        Instant::now()
            .tap(|_| f(&self))
            .pipe(|t| (t.elapsed(), self))
    }

    /// Executes the given closure block,
    /// returns the duration of elapsed time interval and the receiver `self`.
    fn ext_measure_time_with_mut_self(
        mut self,
        f: impl FnOnce(&mut Self) -> R,
    ) -> (Duration, Self) {
        Instant::now()
            .tap(|_| f(&mut self))
            .pipe(|t| (t.elapsed(), self))
    }
}

impl<T, R> StdAnyExt1<R> for T {}

/// This trait is to implement some extension functions for any sized type.
pub trait StdAnyExt: Sized {
    /// System output -> with `:#?`'s `println!`.
    ///
    /// Consumes `self`, `println!` with `:#?`, returns `self`.
    fn dbg(self) -> Self
    where
        Self: Debug,
    {
        self.tap(|s| println!("{s:#?}"))
    }

    /// System output -> with `:?`'s `println!`.
    ///
    /// Consumes `self`, `println!` with `:?`, returns `self`.
    fn sout(self) -> Self
    where
        Self: Debug,
    {
        self.tap(|s| println!("{s:?}"))
    }

    /// Consumes `self`, `println!` as it is, returns `self`.
    fn echo(self) -> Self
    where
        Self: Display,
    {
        self.tap(|s| println!("{s}"))
    }

    /// Convert `value` to `Mutex::new(value)`
    fn into_mutex(self) -> Mutex<Self> {
        self.pipe(Mutex::new)
    }

    /// Convert `value` to `Arc::new(Mutex::new(value))`
    fn into_arc_mutex(self) -> Arc<Mutex<Self>> {
        Arc::new.compose(Mutex::new)(self)
    }

    /// Convert `value` to `RwLock::new(value)`
    fn into_rwlock(self) -> RwLock<Self> {
        self.pipe(RwLock::new)
    }

    /// Convert `value` to `Arc::new(RwLock::new(value))`
    fn into_arc_rwlock(self) -> Arc<RwLock<Self>> {
        Arc::new.compose(RwLock::new)(self)
    }
}

impl<T> StdAnyExt for T {}