relearn 0.3.1

A Reinforcement Learning library
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
126
127
128
129
130
131
132

//! Borrowing utilities.
use serde::{Deserialize, Serialize, Serializer};
use std::borrow::{Cow, ToOwned};
use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
use std::fmt;
use std::hash::{Hash, Hasher};
use std::ops::Deref;

/// Read-only smart-pointer that either owns or borrows the underlying data.
///
/// Like [`Cow`] but does not not require `T: ToOwned`.
#[derive(Copy, Clone, Deserialize)]
#[serde(from = "T")]
pub enum ReadOnly<'a, T> {
    Borrowed(&'a T),
    Owned(T),
}

impl<T> From<T> for ReadOnly<'_, T> {
    #[inline]
    fn from(x: T) -> Self {
        Self::Owned(x)
    }
}

impl<'a, T> From<&'a T> for ReadOnly<'a, T> {
    #[inline]
    fn from(x: &'a T) -> Self {
        Self::Borrowed(x)
    }
}

impl<'a, T: ToOwned<Owned = T>> From<Cow<'a, T>> for ReadOnly<'a, T> {
    #[inline]
    fn from(cow: Cow<'a, T>) -> Self {
        match cow {
            Cow::Borrowed(x) => Self::Borrowed(x),
            Cow::Owned(x) => Self::Owned(x),
        }
    }
}

impl<'a, T: ToOwned<Owned = T>> From<ReadOnly<'a, T>> for Cow<'a, T> {
    #[inline]
    fn from(ro: ReadOnly<'a, T>) -> Self {
        match ro {
            ReadOnly::Borrowed(x) => Self::Borrowed(x),
            ReadOnly::Owned(x) => Self::Owned(x),
        }
    }
}

impl<T: Default> Default for ReadOnly<'_, T> {
    #[inline]
    fn default() -> Self {
        Self::Owned(T::default())
    }
}

impl<T> Deref for ReadOnly<'_, T> {
    type Target = T;
    #[inline]
    fn deref(&self) -> &Self::Target {
        match self {
            Self::Borrowed(x) => x,
            Self::Owned(x) => x,
        }
    }
}

impl<T> AsRef<T> for ReadOnly<'_, T> {
    #[inline]
    fn as_ref(&self) -> &T {
        self
    }
}

impl<T, U> PartialEq<ReadOnly<'_, U>> for ReadOnly<'_, T>
where
    T: PartialEq<U>,
{
    #[inline]
    fn eq(&self, other: &ReadOnly<U>) -> bool {
        PartialEq::eq(&**self, &**other)
    }
}

impl<T: Eq> Eq for ReadOnly<'_, T> {}

impl<T, U> PartialOrd<ReadOnly<'_, U>> for ReadOnly<'_, T>
where
    T: PartialOrd<U>,
{
    #[inline]
    fn partial_cmp(&self, other: &ReadOnly<U>) -> Option<Ordering> {
        PartialOrd::partial_cmp(&**self, &**other)
    }
}

impl<T: Ord> Ord for ReadOnly<'_, T> {
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        Ord::cmp(&**self, &**other)
    }
}

impl<T: fmt::Debug> fmt::Debug for ReadOnly<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&**self, f)
    }
}

impl<T: fmt::Display> fmt::Display for ReadOnly<'_, T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&**self, f)
    }
}

impl<T: Hash> Hash for ReadOnly<'_, T> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        Hash::hash(&**self, state)
    }
}

impl<'a, T: Serialize> Serialize for ReadOnly<'a, T> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        Serialize::serialize(&**self, serializer)
    }
}