vendor/typenum/src/lib.rs

   1 //! This crate provides type-level numbers evaluated at compile time. It depends only on libcore.
   2 //!
   3 //! The traits defined or used in this crate are used in a typical manner. They can be divided into
   4 //! two categories: **marker traits** and **type operators**.
   5 //!
   6 //! Many of the marker traits have functions defined, but they all do essentially the same thing:
   7 //! convert a type into its runtime counterpart, and are really just there for debugging. For
   8 //! example,
   9 //!
  10 //! ```rust
  11 //! use typenum::{Integer, N4};
  12 //!
  13 //! assert_eq!(N4::to_i32(), -4);
  14 //! ```
  15 //!
  16 //! **Type operators** are traits that behave as functions at the type level. These are the meat of
  17 //! this library. Where possible, traits defined in libcore have been used, but their attached
  18 //! functions have not been implemented.
  19 //!
  20 //! For example, the `Add` trait is implemented for both unsigned and signed integers, but the
  21 //! `add` function is not. As there are never any objects of the types defined here, it wouldn't
  22 //! make sense to implement it. What is important is its associated type `Output`, which is where
  23 //! the addition happens.
  24 //!
  25 //! ```rust
  26 //! use std::ops::Add;
  27 //! use typenum::{Integer, P3, P4};
  28 //!
  29 //! type X = <P3 as Add<P4>>::Output;
  30 //! assert_eq!(<X as Integer>::to_i32(), 7);
  31 //! ```
  32 //!
  33 //! In addition, helper aliases are defined for type operators. For example, the above snippet
  34 //! could be replaced with
  35 //!
  36 //! ```rust
  37 //! use typenum::{Integer, Sum, P3, P4};
  38 //!
  39 //! type X = Sum<P3, P4>;
  40 //! assert_eq!(<X as Integer>::to_i32(), 7);
  41 //! ```
  42 //!
  43 //! Documented in each module is the full list of type operators implemented.
  44
  45 #![no_std]
  46 #![forbid(unsafe_code)]
  47 #![warn(missing_docs)]
  48 #![cfg_attr(feature = "strict", deny(missing_docs))]
  49 #![cfg_attr(feature = "strict", deny(warnings))]
  50 #![cfg_attr(
  51     feature = "cargo-clippy",
  52     allow(
  53         clippy::len_without_is_empty,
  54         clippy::many_single_char_names,
  55         clippy::new_without_default,
  56         clippy::suspicious_arithmetic_impl,
  57         clippy::type_complexity,
  58         clippy::wrong_self_convention,
  59     )
  60 )]
  61 #![cfg_attr(feature = "cargo-clippy", deny(clippy::missing_inline_in_public_items))]
  62 #![doc(html_root_url = "https://docs.rs/typenum/1.16.0")]
  63
  64 // For debugging macros:
  65 // #![feature(trace_macros)]
  66 // trace_macros!(true);
  67
  68 use core::cmp::Ordering;
  69
  70 #[cfg(feature = "force_unix_path_separator")]
  71 mod generated {
  72     include!(concat!(env!("OUT_DIR"), "/op.rs"));
  73     include!(concat!(env!("OUT_DIR"), "/consts.rs"));
  74     #[cfg(feature = "const-generics")]
  75     include!(concat!(env!("OUT_DIR"), "/generic_const_mappings.rs"));
  76 }
  77
  78 #[cfg(not(feature = "force_unix_path_separator"))]
  79 mod generated {
  80     include!(env!("TYPENUM_BUILD_OP"));
  81     include!(env!("TYPENUM_BUILD_CONSTS"));
  82     #[cfg(feature = "const-generics")]
  83     include!(env!("TYPENUM_BUILD_GENERIC_CONSTS"));
  84 }
  85
  86 pub mod bit;
  87 pub mod int;
  88 pub mod marker_traits;
  89 pub mod operator_aliases;
  90 pub mod private;
  91 pub mod type_operators;
  92 pub mod uint;
  93
  94 pub mod array;
  95
  96 pub use crate::{
  97     array::{ATerm, TArr},
  98     generated::consts,
  99     int::{NInt, PInt},
 100     marker_traits::*,
 101     operator_aliases::*,
 102     type_operators::*,
 103     uint::{UInt, UTerm},
 104 };
 105
 106 #[doc(no_inline)]
 107 #[rustfmt::skip]
 108 pub use consts::{
 109     False, True, B0, B1,
 110     U0, U1, U2, *,
 111     N1, N2, Z0, P1, P2, *,
 112 };
 113
 114 #[cfg(feature = "const-generics")]
 115 pub use crate::generated::generic_const_mappings;
 116
 117 #[cfg(feature = "const-generics")]
 118 #[doc(no_inline)]
 119 pub use generic_const_mappings::{Const, ToUInt, U};
 120
 121 /// A potential output from `Cmp`, this is the type equivalent to the enum variant
 122 /// `core::cmp::Ordering::Greater`.
 123 #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
 124 #[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))]
 125 pub struct Greater;
 126
 127 /// A potential output from `Cmp`, this is the type equivalent to the enum variant
 128 /// `core::cmp::Ordering::Less`.
 129 #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
 130 #[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))]
 131 pub struct Less;
 132
 133 /// A potential output from `Cmp`, this is the type equivalent to the enum variant
 134 /// `core::cmp::Ordering::Equal`.
 135 #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
 136 #[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))]
 137 pub struct Equal;
 138
 139 /// Returns `core::cmp::Ordering::Greater`
 140 impl Ord for Greater {
 141     #[inline]
 142     fn to_ordering() -> Ordering {
 143         Ordering::Greater
 144     }
 145 }
 146
 147 /// Returns `core::cmp::Ordering::Less`
 148 impl Ord for Less {
 149     #[inline]
 150     fn to_ordering() -> Ordering {
 151         Ordering::Less
 152     }
 153 }
 154
 155 /// Returns `core::cmp::Ordering::Equal`
 156 impl Ord for Equal {
 157     #[inline]
 158     fn to_ordering() -> Ordering {
 159         Ordering::Equal
 160     }
 161 }
 162
 163 /// Asserts that two types are the same.
 164 #[macro_export]
 165 macro_rules! assert_type_eq {
 166     ($a:ty, $b:ty) => {
 167         const _: core::marker::PhantomData<<$a as $crate::Same<$b>>::Output> =
 168             core::marker::PhantomData;
 169     };
 170 }
 171
 172 /// Asserts that a type is `True`, aka `B1`.
 173 #[macro_export]
 174 macro_rules! assert_type {
 175     ($a:ty) => {
 176         const _: core::marker::PhantomData<<$a as $crate::Same<True>>::Output> =
 177             core::marker::PhantomData;
 178     };
 179 }
 180
 181 mod sealed {
 182     use crate::{
 183         ATerm, Bit, Equal, Greater, Less, NInt, NonZero, PInt, TArr, UInt, UTerm, Unsigned, B0, B1,
 184         Z0,
 185     };
 186
 187     pub trait Sealed {}
 188
 189     impl Sealed for B0 {}
 190     impl Sealed for B1 {}
 191
 192     impl Sealed for UTerm {}
 193     impl<U: Unsigned, B: Bit> Sealed for UInt<U, B> {}
 194
 195     impl Sealed for Z0 {}
 196     impl<U: Unsigned + NonZero> Sealed for PInt<U> {}
 197     impl<U: Unsigned + NonZero> Sealed for NInt<U> {}
 198
 199     impl Sealed for Less {}
 200     impl Sealed for Equal {}
 201     impl Sealed for Greater {}
 202
 203     impl Sealed for ATerm {}
 204     impl<V, A> Sealed for TArr<V, A> {}
 205 }