void-1.0.2/.gitignore000064400007650000024000000002071246634165700126760ustar0000000000000000.DS_Store *~ *# *.o *.so *.swp *.dylib *.dSYM *.dll *.rlib *.dummy *.exe *-test /doc/ /target/ /examples/* !/examples/*.rs Cargo.lock void-1.0.2/.travis.yml000064400007650000024000000013201270510530700127760ustar0000000000000000language: rust sudo: false rust: - 1.0.0 - stable - beta - nightly script: - cargo build - cargo test - if [ "$TRAVIS_RUST_VERSION" != "1.0.0" ]; then cargo test --no-default-features; fi - cargo bench --no-run - cargo doc after_success: - if [ "$TRAVIS_PULL_REQUEST" == false && test == "TRAVIS_BRANCH" == "master" ]; then - curl https://raw.githubusercontent.com/reem/rust-gh-docs/master/make-docs.sh > docs.sh - chmod u+x docs.sh - ./docs.sh reem project-name env: global: secure: QPYL1XUr4CyK/2DXlsYC1eCpWRpyEiqQSd/FFVR+YdP/rOJ7AyAXQqPhfgjDBQwvc6E2fUiyYjoV/xe1a757DDeZKlgd8Lp20fSDwvNt/Ejx8ueh3h3kuOtgDpIGSKX/l+XC+ltDpzjhh7bowI2/fOEf+kE53jvu9i4PiLnKdlY= void-1.0.2/Cargo.toml000064400007650000024000000014771270510531700126330ustar0000000000000000# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g. crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "void" version = "1.0.2" authors = ["Jonathan Reem "] description = "The uninhabited void type for use in statically impossible cases." readme = "README.md" license = "MIT" repository = "https://github.com/reem/rust-void.git" [features] default = ["std"] std = [] void-1.0.2/Cargo.toml.orig000064400007650000024000000004661270510531700135670ustar0000000000000000[package] name = "void" version = "1.0.2" authors = ["Jonathan Reem "] repository = "https://github.com/reem/rust-void.git" description = "The uninhabited void type for use in statically impossible cases." readme = "README.md" license = "MIT" [features] default = ["std"] std = [] void-1.0.2/README.md000064400007650000024000000016131266054652100121600ustar0000000000000000# Void > The uninhabited void type for use in statically impossible cases. ## [Documentation](https://crates.fyi/crates/void/1.0.1) The uninhabited type, `enum Void { }` is useful in dealing with cases you know to be impossible. For instance, if you are implementing a trait which allows for error checking, but your case always succeeds, you can mark the error case or type as `Void`, signaling to the compiler it can never happen. This crate also comes packed with a few traits offering extension methods to `Result` and `Result`. ## Usage Use the crates.io repository; add this to your `Cargo.toml` along with the rest of your dependencies: ```toml [dependencies] void = "1" ``` Then, use `Void` in your crate: ```rust extern crate void; use void::Void; ``` ## Author [Jonathan Reem](https://medium.com/@jreem) is the primary author and maintainer of void. ## License MIT void-1.0.2/src/lib.rs000064400007650000024000000054531270510530700126030ustar0000000000000000#![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` and `Result`. //! #[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 cmp::PartialEq for Void { fn eq(&self, _: &T) -> bool { unreachable(*self) } } impl cmp::PartialOrd for Void { fn partial_cmp(&self, _: &T) -> Option { 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` pub trait ResultVoidExt: Sized { /// Get the value out of a wrapper. fn void_unwrap(self) -> T; } impl ResultVoidExt for Result { /// 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` pub trait ResultVoidErrExt: Sized { /// Get the error out of a wrapper. fn void_unwrap_err(self) -> E; } impl ResultVoidErrExt for Result { /// 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 } } }