]>
git.proxmox.com Git - rustc.git/blob - src/libcore/marker.rs
1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Primitive traits and marker types representing basic 'kinds' of types.
13 //! Rust types can be classified in various useful ways according to
14 //! intrinsic properties of the type. These classifications, often called
15 //! 'kinds', are represented as traits.
17 #![stable(feature = "rust1", since = "1.0.0")]
26 /// Types that can be transferred across thread boundaries.
28 /// This trait is automatically derived when the compiler determines it's appropriate.
29 #[stable(feature = "rust1", since = "1.0.0")]
31 #[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"]
32 pub unsafe trait Send
{
36 #[stable(feature = "rust1", since = "1.0.0")]
37 unsafe impl Send
for .. { }
39 #[stable(feature = "rust1", since = "1.0.0")]
40 impl<T
: ?Sized
> !Send
for *const T { }
41 #[stable(feature = "rust1", since = "1.0.0")]
42 impl<T
: ?Sized
> !Send
for *mut T { }
44 /// Types with a constant size known at compile-time.
46 /// All type parameters which can be bounded have an implicit bound of `Sized`. The special syntax
47 /// `?Sized` can be used to remove this bound if it is not appropriate.
50 /// # #![allow(dead_code)]
52 /// struct Bar<T: ?Sized>(T);
54 /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
55 /// struct BarUse(Bar<[i32]>); // OK
57 #[stable(feature = "rust1", since = "1.0.0")]
59 #[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
60 #[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
65 /// Types that can be "unsized" to a dynamically sized type.
66 #[unstable(feature = "unsize", issue = "27732")]
68 pub trait Unsize
<T
: ?Sized
> {
72 /// Types that can be copied by simply copying bits (i.e. `memcpy`).
74 /// By default, variable bindings have 'move semantics.' In other
85 /// // `x` has moved into `y`, and so cannot be used
87 /// // println!("{:?}", x); // error: use of moved value
90 /// However, if a type implements `Copy`, it instead has 'copy semantics':
93 /// // we can just derive a `Copy` implementation
94 /// #[derive(Debug, Copy, Clone)]
101 /// // `y` is a copy of `x`
103 /// println!("{:?}", x); // A-OK!
106 /// It's important to note that in these two examples, the only difference is if you are allowed to
107 /// access `x` after the assignment: a move is also a bitwise copy under the hood.
109 /// ## When can my type be `Copy`?
111 /// A type can implement `Copy` if all of its components implement `Copy`. For example, this
112 /// `struct` can be `Copy`:
115 /// # #[allow(dead_code)]
122 /// A `struct` can be `Copy`, and `i32` is `Copy`, so therefore, `Point` is eligible to be `Copy`.
125 /// # #![allow(dead_code)]
127 /// struct PointList {
128 /// points: Vec<Point>,
132 /// The `PointList` `struct` cannot implement `Copy`, because `Vec<T>` is not `Copy`. If we
133 /// attempt to derive a `Copy` implementation, we'll get an error:
136 /// the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`
139 /// ## When can my type _not_ be `Copy`?
141 /// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
142 /// mutable reference, and copying `String` would result in two attempts to free the same buffer.
144 /// Generalizing the latter case, any type implementing `Drop` can't be `Copy`, because it's
145 /// managing some resource besides its own `size_of::<T>()` bytes.
147 /// ## What if I derive `Copy` on a type that can't?
149 /// If you try to derive `Copy` on a struct or enum, you will get a compile-time error.
150 /// Specifically, with structs you'll get [E0204](https://doc.rust-lang.org/error-index.html#E0204)
151 /// and with enums you'll get [E0205](https://doc.rust-lang.org/error-index.html#E0205).
153 /// ## When should my type be `Copy`?
155 /// Generally speaking, if your type _can_ implement `Copy`, it should. There's one important thing
156 /// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
157 /// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
158 /// change: that second example would fail to compile if we made `Foo` non-`Copy`.
162 /// This trait can be used with `#[derive]` if all of its components implement `Copy` and the type
163 /// implements `Clone`. The implementation will copy the bytes of each field using `memcpy`.
165 /// ## How can I implement `Copy`?
167 /// There are two ways to implement `Copy` on your type:
170 /// #[derive(Copy, Clone)]
178 /// impl Copy for MyStruct {}
179 /// impl Clone for MyStruct { fn clone(&self) -> MyStruct { *self } }
182 /// There is a small difference between the two: the `derive` strategy will also place a `Copy`
183 /// bound on type parameters, which isn't always desired.
184 #[stable(feature = "rust1", since = "1.0.0")]
186 pub trait Copy
: Clone
{
190 /// Types that can be safely shared between threads when aliased.
192 /// The precise definition is: a type `T` is `Sync` if `&T` is
193 /// thread-safe. In other words, there is no possibility of data races
194 /// when passing `&T` references between threads.
196 /// As one would expect, primitive types like `u8` and `f64` are all
197 /// `Sync`, and so are simple aggregate types containing them (like
198 /// tuples, structs and enums). More instances of basic `Sync` types
199 /// include "immutable" types like `&T` and those with simple
200 /// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
201 /// collection types. (Generic parameters need to be `Sync` for their
202 /// container to be `Sync`.)
204 /// A somewhat surprising consequence of the definition is `&mut T` is
205 /// `Sync` (if `T` is `Sync`) even though it seems that it might
206 /// provide unsynchronized mutation. The trick is a mutable reference
207 /// stored in an aliasable reference (that is, `& &mut T`) becomes
208 /// read-only, as if it were a `& &T`, hence there is no risk of a data
211 /// Types that are not `Sync` are those that have "interior
212 /// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
213 /// in `std::cell`. These types allow for mutation of their contents
214 /// even when in an immutable, aliasable slot, e.g. the contents of
215 /// `&Cell<T>` can be `.set`, and do not ensure data races are
216 /// impossible, hence they cannot be `Sync`. A higher level example
217 /// of a non-`Sync` type is the reference counted pointer
218 /// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
219 /// reference, which modifies the reference counts in a non-atomic
222 /// For cases when one does need thread-safe interior mutability,
223 /// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
224 /// the `sync` crate do ensure that any mutation cannot cause data
225 /// races. Hence these types are `Sync`.
227 /// Any types with interior mutability must also use the `std::cell::UnsafeCell`
228 /// wrapper around the value(s) which can be mutated when behind a `&`
229 /// reference; not doing this is undefined behavior (for example,
230 /// `transmute`-ing from `&T` to `&mut T` is invalid).
232 /// This trait is automatically derived when the compiler determines it's appropriate.
233 #[stable(feature = "rust1", since = "1.0.0")]
235 #[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"]
236 pub unsafe trait Sync
{
240 #[stable(feature = "rust1", since = "1.0.0")]
241 unsafe impl Sync
for .. { }
243 #[stable(feature = "rust1", since = "1.0.0")]
244 impl<T
: ?Sized
> !Sync
for *const T { }
245 #[stable(feature = "rust1", since = "1.0.0")]
246 impl<T
: ?Sized
> !Sync
for *mut T { }
250 #[stable(feature = "rust1", since = "1.0.0")]
251 impl<T
:?Sized
> Hash
for $t
<T
> {
253 fn hash
<H
: Hasher
>(&self, _
: &mut H
) {
257 #[stable(feature = "rust1", since = "1.0.0")]
258 impl<T
:?Sized
> cmp
::PartialEq
for $t
<T
> {
259 fn eq(&self, _other
: &$t
<T
>) -> bool
{
264 #[stable(feature = "rust1", since = "1.0.0")]
265 impl<T
:?Sized
> cmp
::Eq
for $t
<T
> {
268 #[stable(feature = "rust1", since = "1.0.0")]
269 impl<T
:?Sized
> cmp
::PartialOrd
for $t
<T
> {
270 fn partial_cmp(&self, _other
: &$t
<T
>) -> Option
<cmp
::Ordering
> {
271 Option
::Some(cmp
::Ordering
::Equal
)
275 #[stable(feature = "rust1", since = "1.0.0")]
276 impl<T
:?Sized
> cmp
::Ord
for $t
<T
> {
277 fn cmp(&self, _other
: &$t
<T
>) -> cmp
::Ordering
{
282 #[stable(feature = "rust1", since = "1.0.0")]
283 impl<T
:?Sized
> Copy
for $t
<T
> { }
285 #[stable(feature = "rust1", since = "1.0.0")]
286 impl<T
:?Sized
> Clone
for $t
<T
> {
287 fn clone(&self) -> $t
<T
> {
292 #[stable(feature = "rust1", since = "1.0.0")]
293 impl<T
:?Sized
> Default
for $t
<T
> {
294 fn default() -> $t
<T
> {
301 /// `PhantomData<T>` allows you to describe that a type acts as if it stores a value of type `T`,
302 /// even though it does not. This allows you to inform the compiler about certain safety properties
305 /// For a more in-depth explanation of how to use `PhantomData<T>`, please see [the Nomicon].
307 /// [the Nomicon]: ../../nomicon/phantom-data.html
309 /// # A ghastly note 👻👻👻
311 /// Though they both have scary names, `PhantomData<T>` and 'phantom types' are related, but not
312 /// identical. Phantom types are a more general concept that don't require `PhantomData<T>` to
313 /// implement, but `PhantomData<T>` is the most common way to implement them in a correct manner.
317 /// ## Unused lifetime parameter
319 /// Perhaps the most common time that `PhantomData` is required is
320 /// with a struct that has an unused lifetime parameter, typically as
321 /// part of some unsafe code. For example, here is a struct `Slice`
322 /// that has two pointers of type `*const T`, presumably pointing into
323 /// an array somewhere:
326 /// struct Slice<'a, T> {
332 /// The intention is that the underlying data is only valid for the
333 /// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
334 /// intent is not expressed in the code, since there are no uses of
335 /// the lifetime `'a` and hence it is not clear what data it applies
336 /// to. We can correct this by telling the compiler to act *as if* the
337 /// `Slice` struct contained a borrowed reference `&'a T`:
340 /// use std::marker::PhantomData;
342 /// # #[allow(dead_code)]
343 /// struct Slice<'a, T: 'a> {
346 /// phantom: PhantomData<&'a T>
350 /// This also in turn requires that we annotate `T:'a`, indicating
351 /// that `T` is a type that can be borrowed for the lifetime `'a`.
353 /// ## Unused type parameters
355 /// It sometimes happens that there are unused type parameters that
356 /// indicate what type of data a struct is "tied" to, even though that
357 /// data is not actually found in the struct itself. Here is an
358 /// example where this arises when handling external resources over a
359 /// foreign function interface. `PhantomData<T>` can prevent
360 /// mismatches by enforcing types in the method implementations:
363 /// # #![allow(dead_code)]
364 /// # trait ResType { fn foo(&self); }
365 /// # struct ParamType;
366 /// # mod foreign_lib {
367 /// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
368 /// # pub fn do_stuff(_: *mut (), _: usize) {}
370 /// # fn convert_params(_: ParamType) -> usize { 42 }
371 /// use std::marker::PhantomData;
374 /// struct ExternalResource<R> {
375 /// resource_handle: *mut (),
376 /// resource_type: PhantomData<R>,
379 /// impl<R: ResType> ExternalResource<R> {
380 /// fn new() -> ExternalResource<R> {
381 /// let size_of_res = mem::size_of::<R>();
382 /// ExternalResource {
383 /// resource_handle: foreign_lib::new(size_of_res),
384 /// resource_type: PhantomData,
388 /// fn do_stuff(&self, param: ParamType) {
389 /// let foreign_params = convert_params(param);
390 /// foreign_lib::do_stuff(self.resource_handle, foreign_params);
395 /// ## Indicating ownership
397 /// Adding a field of type `PhantomData<T>` also indicates that your
398 /// struct owns data of type `T`. This in turn implies that when your
399 /// struct is dropped, it may in turn drop one or more instances of
400 /// the type `T`, though that may not be apparent from the other
401 /// structure of the type itself. This is commonly necessary if the
402 /// structure is using a raw pointer like `*mut T` whose referent
403 /// may be dropped when the type is dropped, as a `*mut T` is
404 /// otherwise not treated as owned.
406 /// If your struct does not in fact *own* the data of type `T`, it is
407 /// better to use a reference type, like `PhantomData<&'a T>`
408 /// (ideally) or `PhantomData<*const T>` (if no lifetime applies), so
409 /// as not to indicate ownership.
410 #[lang = "phantom_data"]
411 #[stable(feature = "rust1", since = "1.0.0")]
412 pub struct PhantomData
<T
:?Sized
>;
414 impls
! { PhantomData }
417 use super::{Send, Sync, Sized}
;
419 #[stable(feature = "rust1", since = "1.0.0")]
420 unsafe impl<'a
, T
: Sync
+ ?Sized
> Send
for &'a T {}
421 #[stable(feature = "rust1", since = "1.0.0")]
422 unsafe impl<'a
, T
: Send
+ ?Sized
> Send
for &'a
mut T {}
425 /// Types that can be reflected over.
427 /// This trait is implemented for all types. Its purpose is to ensure
428 /// that when you write a generic function that will employ
429 /// reflection, that must be reflected (no pun intended) in the
430 /// generic bounds of that function. Here is an example:
433 /// #![feature(reflect_marker)]
434 /// use std::marker::Reflect;
435 /// use std::any::Any;
437 /// # #[allow(dead_code)]
438 /// fn foo<T: Reflect + 'static>(x: &T) {
439 /// let any: &Any = x;
440 /// if any.is::<u32>() { println!("u32"); }
444 /// Without the declaration `T: Reflect`, `foo` would not type check
445 /// (note: as a matter of style, it would be preferable to write
446 /// `T: Any`, because `T: Any` implies `T: Reflect` and `T: 'static`, but
447 /// we use `Reflect` here to show how it works). The `Reflect` bound
448 /// thus serves to alert `foo`'s caller to the fact that `foo` may
449 /// behave differently depending on whether `T = u32` or not. In
450 /// particular, thanks to the `Reflect` bound, callers know that a
451 /// function declared like `fn bar<T>(...)` will always act in
452 /// precisely the same way no matter what type `T` is supplied,
453 /// because there are no bounds declared on `T`. (The ability for a
454 /// caller to reason about what a function may do based solely on what
455 /// generic bounds are declared is often called the ["parametricity
458 /// [1]: http://en.wikipedia.org/wiki/Parametricity
459 #[rustc_reflect_like]
460 #[unstable(feature = "reflect_marker",
461 reason
= "requires RFC and more experience",
463 #[rustc_on_unimplemented = "`{Self}` does not implement `Any`; \
464 ensure all type parameters are bounded by `Any`"]
467 #[unstable(feature = "reflect_marker",
468 reason
= "requires RFC and more experience",
470 impl Reflect
for .. { }