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

#![allow(clippy::missing_safety_doc)]

mod impls;

/// Equivalent of [`core::ops::Try`] that doesn't require nightly and allows changing the output
/// type using a GAT (logically depends on [`core::ops::Try`], but doesn't have an explicit
/// dependency as it's unstable).
///
/// Automatically implemented for Option<T> and Result<T, E>.
pub trait Try {
    type Output;
    type WithOutput<T>: Try;

    fn from_output(output: Self::Output) -> Self;
}

/// Unsafe equivalent of [`From`].
///
/// Used to do unsafe value-to-value conversions while consuming the input value. It is the
/// reciprocal of [`UnsafeInto`].
///
/// One should always prefer implementing `UnsafeFrom` over [`UnsafeInto`] because implementing
/// `UnsafeFrom` automatically provides one with an implementation of [`UnsafeInto`] thanks to the
/// blanket implementation.
///
/// Prefer using [`UnsafeInto`] over using `UnsafeFrom` when specifying trait bounds on a generic
/// function. This way, types that directly implement [`UnsafeInto`] can be used as arguments as
/// well.
///
/// **Note: This trait must not fail**. The `UnsafeFrom` trait is intended for unsafe but perfect
/// conversions. If the conversion can fail or is not perfect, use [`TryFrom`].
///
/// # Generic Implementations
///
/// - `UnsafeFrom<T> for U` implies [`UnsafeInto`]`<U> for T`
/// - `UnsafeFrom`, like [`From`], is reflexive, which means that `UnsafeFrom<T> for T` is
///   implemented
/// - [`From`]`<T> for U` implies `UnsafeFrom<T> for U`
/// - [`Into`]`<U> for T` implies `UnsafeFrom<T> for U`
pub trait UnsafeFrom<T> {
    /// Unsafely converts to this type from the input type.
    unsafe fn unsafe_from(_: T) -> Self;
}

/// Unsafe equivalent of [`Into`].
///
/// Used to do unsafe value-to-value conversions while consuming the input value. It is the
/// reciprocal of [`UnsafeFrom`].
///
/// One should always prefer implementing [`UnsafeFrom`] over `UnsafeInto` because implementing
/// [`UnsafeFrom`] automatically provides one with an implementation of `UnsafeInto` thanks to the
/// blanket implementation.
///
/// Prefer using `UnsafeInto` over using [`UnsafeFrom`] when specifying trait bounds on a generic
/// function. This way, types that directly implement `UnsafeInto` can be used as arguments as
/// well.
///
/// **Note: This trait must not fail**. The `UnsafeInto` trait is intended for unsafe but perfect
/// conversions. If the conversion can fail or is not perfect, use [`TryInto`].
///
/// # Generic Implementations
///
/// - [`UnsafeFrom`]`<T> for U` implies `UnsafeInto<U> for T`
/// - `UnsafeInto`, like [`Into`], is reflexive, which means that `UnsafeInto<T> for T` is
///   implemented
/// - [`From`]`<T> for U` implies `UnsafeInto<U> for T`
/// - [`Into`]`<U> for T` implies `UnsafeInto<U> for T`
pub trait UnsafeInto<T> {
    /// Unsafely converts this type into the input type.
    unsafe fn unsafe_into(self) -> T;
}