Struct TypeHelper

pub struct TypeHelper<T: ?Sized>(/* private fields */);

A helper struct used to determine whether a type implements traits like Send, Sync, and Clone by cooperating with helper traits like NotSend , NotSync, and NotClone.

Helper traits basically have associated constants meaning whether a type imeplements a trait such as Send. They are set to false by default, and all types implement the helper types by blanket implementation. In other words, all types are not Send, Sync by the helper traits, etc. But TypeHelper can overwrite it for types that actually implement those traits thanks to its trait bound. As a result, clients can be aware of whether a type impelments a certain trait through TypeHelper. This is especially useful when you make a library that receives anonymous type and you need such type information.

How it works

If a struct has function foo<T: Send> and it also implement Foo which has the same signature function foo<T>, then rust will look for callable function in the order below.

• Inherent function
• Trait function

So if the type is Send, then rust chooses inherent function due to the search order. But rust will choose trait function if the type is not Send due to the T: Send bound.

See https://doc.rust-lang.org/reference/expressions/method-call-expr.html (Document describes about methods, but I believe the same rule is applied to associated functions as well)

Here, more specific rules are written.

1. https://rust-lang.github.io/rfcs/0195-associated-items.html#via-an-id_segment-prefix
2. https://rust-lang.github.io/rfcs/0195-associated-items.html#via-a-type_segment-prefix

• 1 tells starting with ID_SEGMENT is equivalent to starting with TYPE_SEGMENT. ‘A::b’ is equivalent to ‘<A>::b’
• 2 tells inherent members are prioritized over in-scope traits.

Implementations

impl<T: ?Sized + Send> TypeHelper<T>

pub const IS_SEND: bool = true

impl<T: ?Sized + Sync> TypeHelper<T>

pub const IS_SYNC: bool = true

impl<T: ?Sized + UnwindSafe> TypeHelper<T>

pub const IS_UNWIND_SAFE: bool = true

impl<T: Debug> TypeHelper<T>

pub const IS_DEBUG: bool = true

pub const FN_FMT: FnFmtRaw

pub const fn fn_fmt() -> FnFmtRaw

Returns a raw function pointer of Debug::fmt for the given type.

But the given type is not Debug, then calling the returned function will cause panic.

impl<T: Default> TypeHelper<T>

pub const IS_DEFAULT: bool = true

pub const FN_DEFAULT: FnDefaultRaw

pub const fn fn_default() -> FnDefaultRaw

Returns raw function pointer of Default::default for the given type.

But the given type is not Default, then calling the returned function will cause panic.

impl<T: Clone> TypeHelper<T>

pub const IS_CLONE: bool = true

pub const FN_CLONE: FnCloneRaw

pub const fn fn_clone() -> FnCloneRaw

Returns raw function pointer of Clone::clone for the given type.

But the given type is not Clone, then calling the returned function will cause panic.

impl<T> TypeHelper<(T, T)>

pub const IS_EQUAL_TYPE: bool = true

Trait Implementations

impl<T: ?Sized> NotClone for TypeHelper<T>

const IS_CLONE: bool = false

const FN_CLONE: FnCloneRaw = {ds::types::unimpl_clone as unsafe fn(*const u8, *mut u8)}

impl<T: ?Sized> NotDebug for TypeHelper<T>

const IS_DEBUG: bool = false

const FN_FMT: FnFmtRaw = {ds::types::unimpl_fmt as for<'a, 'b> unsafe fn(*const u8, &'a mut std::fmt::Formatter<'b>) -> std::result::Result<(), std::fmt::Error>}

impl<T: ?Sized> NotDefault for TypeHelper<T>

const IS_DEFAULT: bool = false

const FN_DEFAULT: FnDefaultRaw = {ds::types::unimpl_default as unsafe fn(*mut u8)}

impl<T> NotEqualType for TypeHelper<T>

const IS_EQUAL_TYPE: bool = false

impl<T: ?Sized> NotSend for TypeHelper<T>

const IS_SEND: bool = false

impl<T: ?Sized> NotSync for TypeHelper<T>

const IS_SYNC: bool = false

impl<T: ?Sized> NotUnwindSafe for TypeHelper<T>

const IS_UNWIND_SAFE: bool = false