Module std::marker

Primitive traits and marker types representing basic 'kinds' of types.

Rust types can be classified in various useful ways according to intrinsic properties of the type. These classifications, often called 'kinds', are represented as traits.

They cannot be implemented by user code, but are instead implemented by the compiler automatically for the types to which they apply.

Marker types are special types that are used with unsafe code to inform the compiler of special constraints. Marker types should only be needed when you are creating an abstraction that is implemented using unsafe code. In that case, you may want to embed some of the marker types below into your type.

Structs

PhantomData	PhantomData<T> allows you to describe that a type acts as if it stores a value of type T, even though it does not. This allows you to inform the compiler about certain safety properties of your code.
NoCopy	[Unstable] A type which is considered "not POD", meaning that it is not implicitly copyable. This is typically embedded in other types to ensure that they are never copied, even if they lack a destructor.

Traits

Copy	Types that can be copied by simply copying bits (i.e. memcpy).
Send	Types able to be transferred across thread boundaries.
Sized	Types with a constant size known at compile-time.
Sync	Types that can be safely shared between threads when aliased.
Reflect	[Unstable] A marker trait indicates a type that can be reflected over. This trait is implemented for all types. Its purpose is to ensure that when you write a generic function that will employ reflection, that must be reflected (no pun intended) in the generic bounds of that function. Here is an example:
Unsize	[Unstable] Types that can be "unsized" to a dynamically sized type.