Crate core_extensions

Extension traits for many standard/core library types/traits. and other miscelaneuous types / traits / functions / macros.

Adding as dependency

This crate requires cargo features for enabling items, to get all of them you can use:

[dependencies.core_extensions]
version = "1.0"
features = ["std", "all_items"]

The “std” feature is required to enable impls and items that use std types, otherwise only the core library is supported.

For enabling features individually, look here.

This crate currently requires cargo features to use newer language features,

Examples

Showcasing some features from this crate.

quasiconst, generic constants.

The quasiconst macro allows emulating generic constants by generating a zero-sized generic type that implements the ConstVal trait, the preferred way to get its value is the getconst macro.

This example demonstrates how you can use them to declare a generic VTABLE constant.

use core_extensions::{getconst, quasiconst};

use std::fmt::{self, Debug};


quasiconst!{
   pub const VTABLE<T: Debug>: &'static Vtable = &Vtable {
       size: std::mem::size_of::<T>(),
       align: std::mem::align_of::<T>(),
       drop: drop_erased::<T>,
       fmt: debug_fmt_erased::<T>,
   };
}

const VTABLE_U8: &'static Vtable = getconst!(VTABLE<u8>);
assert_eq!(VTABLE_U8.size, 1);
assert_eq!(VTABLE_U8.align, 1);

const VTABLE_USIZE: &'static Vtable = getconst!(VTABLE<usize>);
assert_eq!(VTABLE_USIZE.size, std::mem::size_of::<usize>());
assert_eq!(VTABLE_USIZE.align, std::mem::align_of::<usize>());

const VTABLE_STRING: &'static Vtable = getconst!(VTABLE<&str>);
assert_eq!(VTABLE_STRING.size, std::mem::size_of::<usize>() * 2);
assert_eq!(VTABLE_STRING.align, std::mem::align_of::<usize>());



pub struct Vtable {
   pub size: usize,
   pub align: usize,
   pub drop: unsafe fn(*mut ()),
   pub fmt: unsafe fn(*const (), &mut fmt::Formatter<'_>) -> fmt::Result,
}

unsafe fn drop_erased<T>(ptr: *mut ()) {
   std::ptr::drop_in_place(ptr as *mut T)
}

unsafe fn debug_fmt_erased<T>(ptr: *const (), f: &mut fmt::Formatter<'_>) -> fmt::Result 
where
   T: Debug,
{
   let this = unsafe{ &*(ptr as *const T) };
    
   Debug::fmt(this, f)
}

no-std support

This crate works in #![no_std] contexts by default.

Supported Rust versions

This crate support Rust back to 1.41.0, requiring cargo features to use language features from newer versions.

Cargo Features

crate features

The "all_items" feature enables all of these features, you can use it instead of the ones below if you don’t mind longer compile-times:

• "bools": Enables the BoolExt trait, extension trait for bool.

• "callable": Enables the callable module, with stably implementable equivalents of the Fn* traits.

• "collections": Enables the collections module, with traits for collection types.

• "const_default": Enables the ConstDefault trait, and const_default macro, for a const equivalent of the Default trait.

• "const_val": Enables the ConstVal trait (for types that represent constants), getconst macro (for getting the ConstVal::VAL associated constant), and quasiconst macro (for declaring types that emulate generic constants). Enables the "generics_parsing" feature.

• "generics_parsing": Enables the parse_generics, parse_generics_and_where, and split_generics_and_where macros. These allow macros to parse items with generic parameters.

• "integers": Enables the integers module, with extension traits for integer types.

• "iterators": Enables the iterators module, with the IteratorExt extension trait for iterators, and a few iterator types.

• "marker_type": Enables the MarkerType trait, for trivially constructible, zero-sized, and aligned-to-1 types.

• "on_drop": Enables the RunOnDrop type, a wrapper type that runs a closure at the end of the scope.

• "option_result": Enables the option_result_ext module, with traits for Option and Result-like types.

• "phantom": Enables the phantom module(with PhantomData-related items), expr_as_phantom macro,map_phantomdata macro, and return_type_phantom macro.

• "self_ops": Enables the SelfOps trait, an extension trait for all types. It primarily has methods for calling free functions as methods.

• "slices": Enables the slices module, with extension traits for [T] and str slices.

• "strings": Enables the strings module, with the StringExt extension trait for strings.

• "transparent_newtype": Enables the transparent_newtype module, with extension traits and functions for #[repr(transparent)] newtypes with public fields.

• "type_asserts": Enables the type_asserts module, with type-level assertiosn, most useful in tests.

• "type_identity": Enables the TypeIdentity trait, for proving that two types are equal, and converting between them in a generic context.

• "type_level_bool": Enables the type_level_bool module, which encodes bools on the type-level.

• "void": Enables the Void type, a type that can’t be constructed, for encodign impossible situations.

Rust Version numbers

These features enable code that require some Rust version past the minimum supported one:

• “rust_1_46”: Makes TransparentNewtype and TypeIdentity associated functions that take Rc<Self> or Arc<Self> callable as methods.

• “rust_1_51”: Enables the “rust_1_46” feature, and impls of traits for all array lengths.

Support for other crates

All of these are disabled by default:

• "std": Enables std library support. Implies the "alloc" feature.

• "alloc": Enables alloc library support.

• "serde_": Enables serde support.

Miscelaneous features

"track_caller": Enables the “rust_1_46” feature. Changes ResultLike to allow getting the caller location in ResultLike::into_result_, and makes IsNoneError store where it was constructed.

"docsrs": Used to document the required features in docs.rs, requires Rust nightly. Doesn’t enable any items itself.

Re-exports

pub use self::callable::CallExt;

pub use self::callable::CallInto;

pub use self::callable::CallMut;

pub use self::callable::CallRef;

pub use self::integers::IntegerExt;

pub use self::integers::ToTime;

pub use self::iterators::IterCloner;

pub use self::iterators::IterConstructor;

pub use self::iterators::IteratorExt;

pub use self::iterators::LazyOnce;

pub use self::option_result_ext::OptionExt;

pub use self::option_result_ext::ResultExt;

pub use self::option_result_ext::ResultLike;

pub use self::option_result_ext::ResultLikeExt;

pub use self::option_result_ext::TransposeOption;

pub use self::phantom::AsPhantomData;

pub use self::phantom::AndPhantom;

pub use self::phantom::AndPhantomCov;

pub use self::phantom::as_phantom;

pub use self::phantom::as_covariant_phantom;

pub use self::phantom::ContraVariantPhantom;

pub use self::phantom::InvariantPhantom;

pub use self::phantom::InvariantRefPhantom;

pub use self::phantom::VariantDropPhantom;

pub use self::phantom::CovariantPhantom;

pub use self::strings::StringExt;

pub use self::slices::ValSliceExt;

pub use self::slices::SliceExt;

pub use self::transparent_newtype::TransparentNewtype;

pub use self::transparent_newtype::TransparentNewtypeExt;

Modules

callable	callable Alternatives of the standard Fn/FnMut/FnOnce traits, implementable in stable Rust.
collections	collections Extension traits for collection types.
integers	integers Extension traits for integers and types used in the traits.
iterators	iterators Iterator adaptors and constructors.
measure_time	Time measurement.
option_result_ext	option_result Contains extension traits for Option and Result
phantom	phantom PhantomData-related items.
slices	slices Slice extension traits, and related items.
strings	slices Extension trait for string types.
transparent_newtype	transparent_newtype Traits for newtype wrappers.
type_asserts	type_asserts Type-level assertions, most useful for tests.
type_level_bool	type_level_bool Type level booleans
utils	Miscelaneous utility functions

Macros

const_default	const_default Gets the ConstDefault::DEFAULT associated constant for a type.
expr_as_phantom	phantom Gets the type of an expression as a PhantomData, without evaluating the expression.
getconst	const_val Gets the ConstVal::VAL associated constant for a type.
impl_call	callable This macro allows more ergonomically implementing the CallRef / CallMut / CallInto traits .
impl_transparent_newtype	transparent_newtype For implementing the TransparentNewtype trait.
iter_cloner	iterators Use this macro to create an IterCloner from an IntoIterator (this includes all Iterators).
map_phantomdata	phantom Maps a PhantomData<T> to a PhantomData<U> by using a FnOnce(T) -> U closure.
matches	Evaluates to true if the expression matches any of the patterns (this macro can have multiple patterns).
parse_generics	generics_parsing Parses a list of generic parameters, and passes them to a macro.
parse_generics_and_where	generics_parsing For writing macros that parse item definitions. This also parses generics for using them in all syntactic locations they’re usable in.
quasiconst	const_val Declare types that emulate generic constants.
return_type_phantom	phantom Gets the return type of a parameterless closure as a PhantomData
split_generics_and_where	generics_parsing For writing macros that parse item definitions, while treating generics opaquely.

Structs

RunOnDrop

on_drop A wrapper type that runs a closure at the end of the scope.

Enums

Void	void Type for impossible situations.

Traits

BoolExt	bools Extension trait for bool.
ConstDefault	const_default A const equivalent of the Default trait.
ConstVal	const_val For types that represent constants.
MarkerType	marker_type Represents a zero-sized marker type .
SelfOps	self_ops Extension trait for every type.
TypeIdentity	type_identity Allows converting Self to Self::Type by proving that both types are equal.

Type Definitions

TIdentity

type_identity A type-level identity function