Crate core_extensions[−][src]

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.
"macro_utils: Enables the rewrap_macro_parameters, count_tts, gen_ident_range, tokens_method, compile_error_stringify, and parenthesize_args macro. Also enables the macro_attr attribute.
"generics_parsing": Enables the parse_generics, parse_generics_and_where, split_generics_and_where, parse_split_generics, and parse_split_generics_and_where macros. These allow macros to parse items with generic parameters.
"item_parsing": Enables the "macro_utils and "generics_parsing" features. Enables the impl_parse_generics and impl_split macros.
"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

compile_error_stringify	`macro_utils` Stringifies the input tokens, and errors with `compile_error`.
const_default	`const_default` Gets the `ConstDefault::DEFAULT` associated constant for a type.
count_tts	`macro_utils` Counts the amount of token trees passed to this macro, passing the amount to an (optional) callback macro.
expr_as_phantom	`phantom` Gets the type of an expression as a `PhantomData`, without evaluating the expression.
gen_ident_range	`macro_utils` Generates identifiers. passing them to a callback macro.
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_parse_generics	`item_parsing` For parsing impl blocks, transforming the generic parameters to a form easily parsable by the callback macro.
impl_split	`item_parsing` For parsing impl blocks, passing the generic parameters unchanged to a callback macro.
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 `Iterator`s).
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).
parenthesize_args	`macro_utils` Adaptor macro which passes arguments to a callback macro, wrapping them in parentheses.
parse_generics	`generics_parsing` Transforms generic parameters for use in type definitions, impl blocks and generic arguments, passing them to a callback macro.
parse_generics_and_where	`generics_parsing` For writing macros that parse item definitions, with the generic parameters transformed for use in type definitions, impl blocks and generic arguments.
parse_split_generics	`generics_parsing` Transforms generic parameters to a form easily parsable by a callback macro.
parse_split_generics_and_where	`generics_parsing` For parsing item definitions, transforming generics to a form easily parsable by a callback macro.
quasiconst	`const_val` Declare types that emulate generic constants.
return_type_phantom	`phantom` Gets the return type of a parameterless closure as a `PhantomData`
rewrap_macro_parameters	`macro_utils` Rewraps the tokens inside macro parameters into parentheses.
split_generics_and_where	`generics_parsing` For parsing item definitions, passing the generic parameters unchanged to a callback macro.
tokens_method	`macro_utils` Does slice and iterator operations on tokens, passing the result to a callback macro.

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

Attribute Macros

macro_attr

macro_utils

For using function-like macros as attributes.

Crate core_extensions⎘[−][src]

Crate core_extensions[−][src]