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
/// A type alias to [`!` (never)][never] that works in places `!` doesn't
/// currently in stable Rust.
///
/// # Examples
///
/// This is a way to indirectly refer to `!` in places where using it
/// directly isn't allowed. Such as simply making an alias to `!` via normal
/// means:
///
/// ```compile_fail
/// type Never = !;
/// ```
///
/// However, with this alias, you can make another alias to `!` indirectly:
///
/// ```
/// type Never = bad::Never;
/// ```
///
/// ## Return type
///
/// Just like `!` can already, `Never` can be used as a function return type:
///
/// ```
/// fn error() -> bad::Never {
/// panic!();
/// }
///
/// let error_fn: fn() -> ! = error;
/// ```
///
/// ## Input type
///
/// Currently, one can't use `!` as a function input type:
///
/// ```compile_fail
/// fn forward(never: !) -> ! {
/// never
/// }
/// ```
///
/// The same goes for expressing the function type:
///
/// ```compile_fail
/// type F = fn(!) -> !;
/// ```
///
/// By using `Never` in place of `!`, the function compiles:
///
/// ```
/// fn forward(never: bad::Never) -> ! {
/// never
/// }
///
/// let forward_fn: fn(bad::Never) -> ! = forward;
/// ```
///
/// ## Trait `impl`s on `!`
///
/// Currently, one can't `impl` custom traits directly on `!`:
///
/// ```compile_fail
/// trait NeverType {}
///
/// impl NeverType for ! {}
/// ```
///
/// By using `Never` in place of `!`, the `impl` works:
///
/// ```
/// # trait NeverType {}
/// impl NeverType for bad::Never {}
/// ```
///
/// However, this isn't of much use since `!` turns into `()` in the context
/// of trait bounds.
///
/// ## Array Item Type
///
/// Currently, one can't use `!` as the item type of an array:
///
/// ```compile_fail
/// let array: [!; 0] = [];
/// ```
///
/// The same for slices:
///
/// ```compile_fail
/// let slice: &[!] = &[];
/// ```
///
/// By using `Never` in place of `!` the above works:
///
/// ```
/// let array: [bad::Never; 0] = [];
/// let slice: &[bad::Never] = &[];
/// ```
///
/// [never]: https://doc.rust-lang.org/std/primitive.never.html
pub type Never = Output;
// Declared public to prevent errors when externally used. This is locally
// guarded against by denying `private_in_public` everywhere. However, it should
// not be actually publicly exposed. This is locally guarded against by denying
// `missing_docs` everywhere.
type F = fn !;