// These links overwrite the ones in `README.md`
// to become proper intra-doc links in Rust docs.
//! [`From`]: macro@crate::From
//! [`Into`]: macro@crate::Into
//! [`FromStr`]: macro@crate::FromStr
//! [`TryFrom`]: macro@crate::TryFrom
//! [`TryInto`]: macro@crate::TryInto
//! [`IntoIterator`]: macro@crate::IntoIterator
//! [`AsRef`]: macro@crate::AsRef
//!
//! [`Debug`]: macro@crate::Debug
//! [`Display`-like]: macro@crate::Display
//!
//! [`Error`]: macro@crate::Error
//!
//! [`Index`]: macro@crate::Index
//! [`Deref`]: macro@crate::Deref
//! [`Not`-like]: macro@crate::Not
//! [`Add`-like]: macro@crate::Add
//! [`Mul`-like]: macro@crate::Mul
//! [`Sum`-like]: macro@crate::Sum
//! [`IndexMut`]: macro@crate::IndexMut
//! [`DerefMut`]: macro@crate::DerefMut
//! [`AddAssign`-like]: macro@crate::AddAssign
//! [`MulAssign`-like]: macro@crate::MulAssign
//!
//! [`Constructor`]: macro@crate::Constructor
//! [`IsVariant`]: macro@crate::IsVariant
//! [`Unwrap`]: macro@crate::Unwrap
//! [`TryUnwrap`]: macro@crate::TryUnwrap
// The README includes doctests requiring these features. To make sure that
// tests pass when not all features are provided we exclude it when the
// required features are not available.
#![cfg_attr(
all(
feature =
"add",
feature =
"display",
feature =
"from",
feature =
"into"
),
doc = include_str!(
"../README.md")
)]
#![cfg_attr(not(feature =
"std"), no_std)]
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![cfg_attr(any(not(docsrs), ci), deny(rustdoc::all))]
#![forbid(non_ascii_idents, unsafe_code)]
#![warn(clippy::nonstandard_macro_braces)]
// For macro expansion internals only.
// Ensures better hygiene in case a local crate `core` is present in workspace of the user code,
// or some other crate is renamed as `core`.
#[doc(hidden)]
pub use core;
// Not public, but exported API. For macro expansion internals only.
#[doc(hidden)]
pub mod __private {
#[cfg(feature =
"as_ref")]
pub use crate::r
#as::{Conv, ExtractRef};
#[cfg(feature =
"debug")]
pub use crate::fmt::{debug_tuple, DebugTuple};
#[cfg(feature =
"error")]
pub use crate::vendor::thiserror::aserror::AsDynError;
}
// The modules containing error types and other helpers.
#[cfg(feature =
"add")]
mod add;
#[cfg(feature =
"add")]
pub use crate::add::{BinaryError, WrongVariantError};
#[cfg(any(feature =
"add", feature =
"not"))]
mod ops;
#[cfg(any(feature =
"add", feature =
"not"))]
pub use crate::ops::UnitError;
#[cfg(feature =
"as_ref")]
mod r
#as;
#[cfg(feature =
"debug")]
mod fmt;
#[cfg(feature =
"error")]
mod vendor;
#[cfg(feature =
"from_str")]
mod r
#str;
#[cfg(feature =
"from_str")]
#[doc(inline)]
pub use crate::r
#str::FromStrError;
#[cfg(any(feature =
"try_into", feature =
"try_from"))]
mod convert;
#[cfg(feature =
"try_from")]
#[doc(inline)]
pub use crate::convert::TryFromReprError;
#[cfg(feature =
"try_into")]
#[doc(inline)]
pub use crate::convert::TryIntoError;
#[cfg(feature =
"try_unwrap")]
mod try_unwrap;
#[cfg(feature =
"try_unwrap")]
#[doc(inline)]
pub use crate::try_unwrap::TryUnwrapError;
// This can be unused if no feature is enabled. We already error in that case, but this warning
// distracts from that error. So we suppress the warning.
#[allow(unused_imports)]
#[doc(inline)]
pub use derive_more_impl::*;
/// Module containing derive definitions only, without their corresponding traits.
///
/// Use it in your import paths, if you don't want to import traits, but only macros.
pub mod derive {
// This can be unused if no feature is enabled. We already error in that case, but this warning
// distracts from that error. So we suppress the warning.
#[allow(unused_imports)]
#[doc(inline)]
pub use derive_more_impl::*;
}
/// Module containing derive definitions with their corresponding traits along.
///
/// Use it in your import paths, if you do want to import derives along with their traits.
pub mod with_trait {
// When re-exporting traits from `std` we need to do a pretty crazy trick, because we ONLY want
// to re-export the traits and not derives that are called the same in the `std` module, because
// those would conflict with our own ones. The way we do this is by first importing both the
// trait and possible derive into a separate module and re-export them. Then, we wildcard-import
// all the things from that module into the main module, but we also import our own derive by
// its exact name. Due to the way wildcard imports work in Rust, that results in our own derive
// taking precedence over any derive from `std`. For some reason the named re-export of our own
// derive cannot be in this (or really any) macro too. It will somehow still consider it a
// wildcard then and will result in this warning `ambiguous_glob_reexports`, and not actually
// exporting of our derive.
macro_rules! re_export_traits((
$feature:literal, $new_module_name:ident, $module:path $(, $traits:ident)* $(,)?) => {
#[cfg(all(feature = $feature, any(not(docsrs), ci)))]
mod $new_module_name {
#[doc(hidden)]
pub use $module::{$($traits),*};
}
#[cfg(all(feature = $feature, any(not(docsrs), ci)))]
#[doc(hidden)]
pub use crate::with_trait::all_traits_and_derives::$new_module_name::*;
}
);
mod all_traits_and_derives {
re_export_traits!(
"add",
add_traits,
core::ops,
Add,
BitAnd,
BitOr,
BitXor,
Sub,
);
re_export_traits!(
"add_assign",
add_assign_traits,
core::ops,
AddAssign,
BitAndAssign,
BitOrAssign,
BitXorAssign,
SubAssign,
);
re_export_traits!(
"as_ref", as_ref_traits, core::convert, AsMut, AsRef);
re_export_traits!(
"debug", debug_traits, core::fmt, Debug);
re_export_traits!(
"deref", deref_traits, core::ops, Deref);
re_export_traits!(
"deref_mut", deref_mut_traits, core::ops, DerefMut);
re_export_traits!(
"display",
display_traits,
core::fmt,
Binary,
Display,
LowerExp,
LowerHex,
Octal,
Pointer,
UpperExp,
UpperHex,
);
#[cfg(not(feature =
"std"))]
re_export_traits!(
"error", error_traits, core::error, Error);
#[cfg(feature =
"std")]
re_export_traits!(
"error", error_traits, std::error, Error);
re_export_traits!(
"from", from_traits, core::convert, From);
re_export_traits!(
"from_str", from_str_traits, core::str, FromStr);
re_export_traits!(
"index", index_traits, core::ops, Index);
re_export_traits!(
"index_mut", index_mut_traits, core::ops, IndexMut);
re_export_traits!(
"into", into_traits, core::convert, Into);
re_export_traits!(
"into_iterator",
into_iterator_traits,
core::iter,
IntoIterator,
);
re_export_traits!(
"mul", mul_traits, core::ops, Div, Mul, Rem, Shl, Shr);
#[cfg(feature =
"mul_assign")]
re_export_traits!(
"mul_assign",
mul_assign_traits,
core::ops,
DivAssign,
MulAssign,
RemAssign,
ShlAssign,
ShrAssign,
);
re_export_traits!(
"not", not_traits, core::ops, Neg, Not);
re_export_traits!(
"sum", sum_traits, core::iter, Product, Sum);
re_export_traits!(
"try_from", try_from_traits, core::convert, TryFrom);
re_export_traits!(
"try_into", try_into_traits, core::convert, TryInto);
// Now re-export our own derives by their exact name to overwrite any derives that the trait
// re-exporting might inadvertently pull into scope.
#[cfg(feature =
"add")]
pub use derive_more_impl::{Add, BitAnd, BitOr, BitXor, Sub};
#[cfg(feature =
"add_assign")]
pub use derive_more_impl::{
AddAssign, BitAndAssign, BitOrAssign, BitXorAssign, SubAssign,
};
#[cfg(feature =
"as_ref")]
pub use derive_more_impl::{AsMut, AsRef};
#[cfg(feature =
"constructor")]
pub use derive_more_impl::Constructor;
#[cfg(feature =
"debug")]
pub use derive_more_impl::Debug;
#[cfg(feature =
"deref")]
pub use derive_more_impl::Deref;
#[cfg(feature =
"deref_mut")]
pub use derive_more_impl::DerefMut;
#[cfg(feature =
"display")]
pub use derive_more_impl::{
Binary, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex,
};
#[cfg(feature =
"error")]
pub use derive_more_impl::Error;
#[cfg(feature =
"from")]
pub use derive_more_impl::From;
#[cfg(feature =
"from_str")]
pub use derive_more_impl::FromStr;
#[cfg(feature =
"index")]
pub use derive_more_impl::Index;
#[cfg(feature =
"index_mut")]
pub use derive_more_impl::IndexMut;
#[cfg(feature =
"into")]
pub use derive_more_impl::Into;
#[cfg(feature =
"into_iterator")]
pub use derive_more_impl::IntoIterator;
#[cfg(feature =
"is_variant")]
pub use derive_more_impl::IsVariant;
#[cfg(feature =
"mul")]
pub use derive_more_impl::{Div, Mul, Rem, Shl, Shr};
#[cfg(feature =
"mul_assign")]
pub use derive_more_impl::{
DivAssign, MulAssign, RemAssign, ShlAssign, ShrAssign,
};
#[cfg(feature =
"not")]
pub use derive_more_impl::{Neg, Not};
#[cfg(feature =
"sum")]
pub use derive_more_impl::{Product, Sum};
#[cfg(feature =
"try_from")]
pub use derive_more_impl::TryFrom;
#[cfg(feature =
"try_into")]
pub use derive_more_impl::TryInto;
#[cfg(feature =
"try_unwrap")]
pub use derive_more_impl::TryUnwrap;
#[cfg(feature =
"unwrap")]
pub use derive_more_impl::Unwrap;
}
// Now re-export our own derives and the std traits by their exact name to make rust-analyzer
// recognize the #[doc(hidden)] flag.
// See issues:
// 1. https://github.com/rust-lang/rust-analyzer/issues/11698
// 2. https://github.com/rust-lang/rust-analyzer/issues/14079
#[cfg(feature =
"add")]
#[doc(hidden)]
pub use all_traits_and_derives::{Add, BitAnd, BitOr, BitXor, Sub};
#[cfg(feature =
"add_assign")]
#[doc(hidden)]
pub use all_traits_and_derives::{
AddAssign, BitAndAssign, BitOrAssign, BitXorAssign, SubAssign,
};
#[cfg(feature =
"as_ref")]
#[doc(hidden)]
pub use all_traits_and_derives::{AsMut, AsRef};
#[cfg(feature =
"constructor")]
#[doc(hidden)]
pub use all_traits_and_derives::Constructor;
#[cfg(feature =
"debug")]
#[doc(hidden)]
pub use all_traits_and_derives::Debug;
#[cfg(feature =
"deref")]
#[doc(hidden)]
pub use all_traits_and_derives::Deref;
#[cfg(feature =
"deref_mut")]
#[doc(hidden)]
pub use all_traits_and_derives::DerefMut;
#[cfg(feature =
"display")]
#[doc(hidden)]
pub use all_traits_and_derives::{
Binary, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex,
};
#[cfg(feature =
"error")]
#[doc(hidden)]
pub use all_traits_and_derives::Error;
#[cfg(feature =
"from")]
#[doc(hidden)]
pub use all_traits_and_derives::From;
#[cfg(feature =
"from_str")]
#[doc(hidden)]
pub use all_traits_and_derives::FromStr;
#[cfg(feature =
"index")]
#[doc(hidden)]
pub use all_traits_and_derives::Index;
#[cfg(feature =
"index_mut")]
#[doc(hidden)]
pub use all_traits_and_derives::IndexMut;
#[cfg(feature =
"into")]
#[doc(hidden)]
pub use all_traits_and_derives::Into;
#[cfg(feature =
"into_iterator")]
#[doc(hidden)]
pub use all_traits_and_derives::IntoIterator;
#[cfg(feature =
"is_variant")]
#[doc(hidden)]
pub use all_traits_and_derives::IsVariant;
#[cfg(feature =
"mul")]
#[doc(hidden)]
pub use all_traits_and_derives::{Div, Mul, Rem, Shl, Shr};
#[cfg(feature =
"mul_assign")]
#[doc(hidden)]
pub use all_traits_and_derives::{
DivAssign, MulAssign, RemAssign, ShlAssign, ShrAssign,
};
#[cfg(feature =
"not")]
#[doc(hidden)]
pub use all_traits_and_derives::{Neg, Not};
#[cfg(feature =
"sum")]
#[doc(hidden)]
pub use all_traits_and_derives::{Product, Sum};
#[cfg(feature =
"try_from")]
#[doc(hidden)]
pub use all_traits_and_derives::TryFrom;
#[cfg(feature =
"try_into")]
#[doc(hidden)]
pub use all_traits_and_derives::TryInto;
#[cfg(feature =
"try_unwrap")]
#[doc(hidden)]
pub use all_traits_and_derives::TryUnwrap;
#[cfg(feature =
"unwrap")]
#[doc(hidden)]
pub use all_traits_and_derives::Unwrap;
// Re-export the derive macros again to show docs for our derives (but not for traits). This is
// done using a glob import to not hit E0252.
#[allow(unused_imports)]
pub use derive_more_impl::*;
}
// Check if any feature is enabled
#[cfg(not(any(
feature =
"full",
feature =
"add",
feature =
"add_assign",
feature =
"as_ref",
feature =
"constructor",
feature =
"debug",
feature =
"deref",
feature =
"deref_mut",
feature =
"display",
feature =
"error",
feature =
"from",
feature =
"from_str",
feature =
"index",
feature =
"index_mut",
feature =
"into",
feature =
"into_iterator",
feature =
"is_variant",
feature =
"mul",
feature =
"mul_assign",
feature =
"not",
feature =
"sum",
feature =
"try_from",
feature =
"try_into",
feature =
"try_unwrap",
feature =
"unwrap",
)))]
compile_error!(
"at least one derive feature must be enabled (or the \"full\
" feature enabling all the derives)"
);
