forkable 0.1.0

Fork-able iterators and asynchronous streams.
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

use core::ops::Deref;

use crate::alloc::{
    rc::Rc,
    sync::Arc
};


macro_rules! maybe {
    ($(#[$target_meta:meta])* $target_vis:vis $target_ty:ident  $($target_tt:tt)+) => {
        ::paste::paste! {
            $(#[$target_meta])*
            $target_vis enum [< Maybe $target_ty >] $($target_tt)+ {
                Owned(T),
                $target_ty ($target_ty $($target_tt)+)
            }

            impl<T> Deref for [< Maybe $target_ty >] $($target_tt)+ {
                type Target = T;

                fn deref(&self) -> &Self::Target {
                    match self {
                        Self::Owned(inner) => inner,
                        Self:: $target_ty (inner) => inner
                    }
                }
            }

            impl<T> [< Maybe $target_ty >] $($target_tt)+
            where
                $target_ty <T> : Clone
            {
                pub fn make_clone(self) -> (Self, Self) {
                    match self {
                        Self::Owned(inner) => {
                            let shared_value = $target_ty :: from(inner);

                            (
                                Self:: $target_ty ( <$target_ty <T> as Clone>::clone(&shared_value) ), Self:: $target_ty ( shared_value )
                            )
                        },
                        Self:: $target_ty (ref inner) => (Self:: $target_ty (<$target_ty <T> as Clone>::clone(inner)), self)
                    }
                }
            }

            impl<T> From<T> for [< Maybe $target_ty >] <T>
            {
                fn from(target_value: T) -> Self {
                    Self::Owned(target_value)
                }
            }

            
            impl<T> From< $target_ty  <T>> for [< Maybe $target_ty >] <T>
            {
                fn from(target_value: $target_ty <T>) -> Self {
                    Self :: $target_ty (target_value)
                }
            }
        }
    };
}

maybe!(
    pub Rc<T>
);

maybe!(
    pub Arc<T>
);