      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

    #![cfg_attr(test, deny(warnings))]
    #![deny(missing_docs)]
    #![cfg_attr(not(feature = "std"), no_std)]

    //! # Void
    //!
    //! The uninhabited void type for use in statically impossible cases.
    //!
    //! In its own crate so all the users in the ecosystem can share the same type.
    //! This crate also comes ready with several extension traits for Result that add
    //! extra functionality to `Result<T, Void>` and `Result<Void, E>`.
    //!

    #[cfg(not(feature = "std"))]
    mod coreprovider {
        extern crate core;
        pub use core::{fmt, cmp};
    }

    #[cfg(feature = "std")]
    mod coreprovider {
        pub use std::{fmt, cmp, error};
    }

    use coreprovider::*;

    /// The empty type for cases which can't occur.
    #[derive(Copy)]
    pub enum Void { }

    impl Clone for Void {
        fn clone(&self) -> Void {
            unreachable(*self)
        }
    }

    impl fmt::Debug for Void {
        fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
            unreachable(*self)
        }
    }

    impl fmt::Display for Void {
        fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
            unreachable(*self)
        }
    }

    impl<T> cmp::PartialEq<T> for Void {
        fn eq(&self, _: &T) -> bool {
            unreachable(*self)
        }
    }

    impl<T> cmp::PartialOrd<T> for Void {
        fn partial_cmp(&self, _: &T) -> Option<cmp::Ordering> {
            unreachable(*self)
        }
    }

    #[cfg(feature = "std")]
    impl error::Error for Void {
        fn description(&self) -> &str {
            unreachable(*self)
        }

        fn cause(&self) -> Option<&error::Error> {
            unreachable(*self)
        }
    }

    /// A safe version of `intrinsincs::unreachable`.
    ///
    /// If this typechecks, anything that causes this to run is unreachable code.
    ///
    /// Calling this function in reachable code invokes undefined behavior, but
    /// should not be possible unless `unsafe` was used elsewhere to construct
    /// an instance of `Void` (which is already undefined behavior).
    #[inline(always)]
    pub fn unreachable(x: Void) -> ! {
        match x {}
    }

    /// Extensions to `Result<T, Void>`
    pub trait ResultVoidExt<T>: Sized {
        /// Get the value out of a wrapper.
        fn void_unwrap(self) -> T;
    }

    impl<T> ResultVoidExt<T> for Result<T, Void> {
        /// Get the value out of an always-ok Result.
        ///
        /// Never panics, since it is statically known to be Ok.
        #[inline]
        fn void_unwrap(self) -> T {
            match self {
                Ok(val) => val,
                Err(e) => unreachable(e)
            }
        }
    }

    /// Extensions to `Result<Void, E>`
    pub trait ResultVoidErrExt<E>: Sized {
        /// Get the error out of a wrapper.
        fn void_unwrap_err(self) -> E;
    }

    impl<E> ResultVoidErrExt<E> for Result<Void, E> {
        /// Get the error out of an always-err Result.
        ///
        /// Never panics, since it is statically known to be Err.
        #[inline]
        fn void_unwrap_err(self) -> E {
            match self {
                Ok(v) => unreachable(v),
                Err(e) => e
            }
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)