kutil 0.0.6

Kutil utilities collection
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

use std::borrow::*;

//
// Calf
//

/// A read-only container for either an owned value or a reference to one.
///
/// Similar to [Cow], but does not support [ToOwned] (and does not require your
/// value to support it), nor does it support [BorrowMut].
///
/// It's a baby cow!
///
/// Note that after coming up with the idea for this, I discovered that someone
/// else did, too. Check out [maybe-owned](https://github.com/rustonaut/maybe-owned)
/// for an identical type that comes with a zillion more trait implementations.
pub enum Calf<'borrow, BorrowedT> {
    /// Borrowed.
    Borrowed(&'borrow BorrowedT),

    /// Owned.
    Owned(BorrowedT),
}

impl<'borrow, BorrowedT> Calf<'borrow, BorrowedT> {
    /// Are we borrowed?
    pub fn is_borrowed(&self) -> bool {
        matches!(self, Self::Borrowed(_))
    }

    /// Are we owned?
    pub fn is_owned(&self) -> bool {
        matches!(self, Self::Owned(_))
    }
}

impl<'borrow, BorrowedT> Borrow<BorrowedT> for Calf<'borrow, BorrowedT> {
    fn borrow(&self) -> &BorrowedT {
        match self {
            Self::Owned(owned) => owned,
            Self::Borrowed(borrowed) => *borrowed,
        }
    }
}

// Experimental

impl<'borrow, BorrowedT, OwnedT> Calf<'borrow, BorrowedT>
where
    BorrowedT: ToOwned<Owned = OwnedT>,
{
    /// Into owned.
    pub fn into_owned(self) -> <BorrowedT as ToOwned>::Owned {
        match self {
            Self::Owned(owned) => owned.to_owned(),
            Self::Borrowed(borrowed) => borrowed.to_owned(),
        }
    }
}

impl<'borrow, BorrowedT> BorrowMut<BorrowedT> for Calf<'borrow, BorrowedT>
where
    &'borrow BorrowedT: AsMut<&'borrow mut BorrowedT>,
{
    fn borrow_mut(&mut self) -> &mut BorrowedT {
        match self {
            Self::Owned(owned) => owned,
            Self::Borrowed(borrowed) => borrowed.as_mut(),
        }
    }
}

impl<'borrow, BorrowedT, OwnedT> ToOwned for Calf<'borrow, BorrowedT>
where
    BorrowedT: ToOwned<Owned = OwnedT>,
    OwnedT: Borrow<Self>,
{
    type Owned = OwnedT;

    fn to_owned(&self) -> OwnedT {
        match self {
            Self::Owned(owned) => owned.to_owned(),
            Self::Borrowed(borrowed) => (*borrowed).to_owned(),
        }
    }
}

// Conversions

impl<'borrow, BorrowedT> From<Cow<'borrow, BorrowedT>> for Calf<'borrow, BorrowedT>
where
    BorrowedT: ToOwned<Owned = BorrowedT>,
{
    fn from(cow: Cow<'borrow, BorrowedT>) -> Self {
        match cow {
            Cow::Owned(owned) => Calf::Owned(owned),
            Cow::Borrowed(borrowed) => Calf::Borrowed(borrowed),
        }
    }
}

impl<'borrow, BorrowedT> From<Calf<'borrow, BorrowedT>> for Cow<'borrow, BorrowedT>
where
    BorrowedT: ToOwned<Owned = BorrowedT>,
{
    fn from(calf: Calf<'borrow, BorrowedT>) -> Self {
        match calf {
            Calf::Owned(owned) => Cow::Owned(owned),
            Calf::Borrowed(borrowed) => Cow::Borrowed(borrowed),
        }
    }
}