butcher 0.5.0

An easy way to interact with structs and enums wrapped in Cows
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

//! Allows to dereference the content of a `Cow`, lowering the level of
//! indirection.
//!
//! For instance, this allows to convert a `Cow<String>` to a `Cow<str>`, which
//! is easier to deal with.

use std::borrow::Cow;
use std::ops::Deref;

fn as_deref_cow<T>(input: Cow<T>) -> Cow<<T as Deref>::Target>
where
    T: Deref + ToOwned,
    <T as Deref>::Target: ToOwned,
    <<T as Deref>::Target as ToOwned>::Owned: From<<T as ToOwned>::Owned>,
{
    match input {
        Cow::Borrowed(input) => Cow::Borrowed(input.deref()),
        Cow::Owned(input) => Cow::Owned(input.into()),
    }
}

/// Allows to dereference the content of a `Cow`.
///
/// The best use case for this is to transform a `Cow<String>` into a
/// `Cow<str>`. This also works for the boxed unsized type, as long as they
/// implement the traits as required below.
///
/// # Example
///
/// The following example shows the flattening of `Cow<String>` and
/// `Cow<PathBuf>`:
///
/// ```rust
/// use std::{
///     borrow::Cow,
///     path::{Path, PathBuf},
/// };
///
/// use butcher::as_deref::AsDerefCow;
///
/// // The type is annotated so that it is easier to understand what's happening
/// let a: Cow<String> = Cow::Owned(String::from("Grace Hopper"));
/// let a_as_deref: Cow<str> = a.as_deref();
/// assert_eq!(a_as_deref, "Grace Hopper");
///
/// let b: Cow<PathBuf> = Cow::Owned(PathBuf::from("/path/to/foo"));
/// let b_as_deref: Cow<Path> = b.as_deref();
/// assert_eq!(b_as_deref, Path::new("/path/to/foo"));
/// ```
///
/// # Traits requirements
///
/// In order to call `as_deref` on a `Cow<T>`, the following requirements must be
/// satisified:
///   - `T` must implement [`ToOwned`], which is required to build the initial
///   `Cow<T>`,
///   - `T` must implement [`Deref`], and its `Target` must also implement
///   [`ToOwned`], which is required to build the output
///   `Cow<<T as Deref>::Target>`, and when the borrowed case is met,
///   - `T` must be convertible into the `Owned` type associated to the `Target`
///   dereferenced type, which is required when the owned case is met.
///
/// [`ToOwned`]: https://doc.rust-lang.org/std/borrow/trait.ToOwned.html
/// [`Deref`]: https://doc.rust-lang.org/std/ops/trait.Deref.html
pub trait AsDerefCow<'cow, T>
where
    T: Deref,
    <T as Deref>::Target: ToOwned,
{
    fn as_deref(self) -> Cow<'cow, <T as Deref>::Target>;
}

impl<'cow, T> AsDerefCow<'cow, T> for Cow<'cow, T>
where
    T: Deref + ToOwned,
    <T as Deref>::Target: ToOwned,
    <<T as Deref>::Target as ToOwned>::Owned: From<<T as ToOwned>::Owned>,
{
    fn as_deref(self) -> Cow<'cow, <T as Deref>::Target> {
        as_deref_cow(self)
    }
}

#[cfg(test)]
mod flatten_fn {
    use super::*;

    #[test]
    fn as_deref_cow_string_owned() {
        let input: Cow<String> = Cow::Owned(String::from("foo"));
        let output: Cow<str> = as_deref_cow(input);

        assert!(matches!(output, Cow::Owned(_)));
        assert_eq!(output, "foo");
    }

    #[test]
    fn as_deref_cow_string_borrowed() {
        let tmp = String::from("bar");
        let input: Cow<String> = Cow::Borrowed(&tmp);
        let output: Cow<str> = as_deref_cow(input);

        assert!(matches!(output, Cow::Borrowed(_)));
        assert_eq!(output, "bar");
    }

    #[test]
    fn as_deref_cow_box_str_owned() {
        let input: Cow<Box<str>> = Cow::Owned(Box::from("foo"));
        let output: Cow<str> = as_deref_cow(input);

        assert!(matches!(output, Cow::Owned(_)));
        assert_eq!(output, "foo");
    }

    #[test]
    fn as_deref_cow_box_str_borrowed() {
        let tmp = Box::from("bar");
        let input: Cow<Box<str>> = Cow::Borrowed(&tmp);
        let output: Cow<str> = as_deref_cow(input);

        assert!(matches!(output, Cow::Borrowed(_)));
        assert_eq!(output, "bar");
    }
}