1 //! Primitive traits and types representing basic properties of types.
3 //! Rust types can be classified in various useful ways according to
4 //! their intrinsic properties. These classifications are represented
7 #![stable(feature = "rust1", since = "1.0.0")]
9 use crate::cell::UnsafeCell;
11 use crate::fmt::Debug;
12 use crate::hash::Hash;
13 use crate::hash::Hasher;
15 /// Types that can be transferred across thread boundaries.
17 /// This trait is automatically implemented when the compiler determines it's
20 /// An example of a non-`Send` type is the reference-counting pointer
21 /// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to the same
22 /// reference-counted value, they might try to update the reference count at the
23 /// same time, which is [undefined behavior][ub] because [`Rc`] doesn't use atomic
24 /// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring
25 /// some overhead) and thus is `Send`.
27 /// See [the Nomicon](../../nomicon/send-and-sync.html) for more details.
29 /// [`Rc`]: ../../std/rc/struct.Rc.html
30 /// [arc]: ../../std/sync/struct.Arc.html
31 /// [ub]: ../../reference/behavior-considered-undefined.html
32 #[stable(feature = "rust1", since = "1.0.0")]
33 #[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
34 #[rustc_on_unimplemented(
35 message = "`{Self}` cannot be sent between threads safely",
36 label = "`{Self}` cannot be sent between threads safely"
38 pub unsafe auto trait Send {
42 #[stable(feature = "rust1", since = "1.0.0")]
43 impl<T: ?Sized> !Send for *const T {}
44 #[stable(feature = "rust1", since = "1.0.0")]
45 impl<T: ?Sized> !Send for *mut T {}
47 // Most instances arise automatically, but this instance is needed to link up `T: Sync` with
48 // `&T: Send` (and it also removes the unsound default instance `T Send` -> `&T: Send` that would
50 #[stable(feature = "rust1", since = "1.0.0")]
51 unsafe impl<T: Sync + ?Sized> Send for &T {}
53 /// Types with a constant size known at compile time.
55 /// All type parameters have an implicit bound of `Sized`. The special syntax
56 /// `?Sized` can be used to remove this bound if it's not appropriate.
59 /// # #![allow(dead_code)]
61 /// struct Bar<T: ?Sized>(T);
63 /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
64 /// struct BarUse(Bar<[i32]>); // OK
67 /// The one exception is the implicit `Self` type of a trait. A trait does not
68 /// have an implicit `Sized` bound as this is incompatible with [trait object]s
69 /// where, by definition, the trait needs to work with all possible implementors,
70 /// and thus could be any size.
72 /// Although Rust will let you bind `Sized` to a trait, you won't
73 /// be able to use it to form a trait object later:
76 /// # #![allow(unused_variables)]
78 /// trait Bar: Sized { }
81 /// impl Foo for Impl { }
82 /// impl Bar for Impl { }
84 /// let x: &dyn Foo = &Impl; // OK
85 /// // let y: &dyn Bar = &Impl; // error: the trait `Bar` cannot
86 /// // be made into an object
89 /// [trait object]: ../../book/ch17-02-trait-objects.html
90 #[doc(alias = "?", alias = "?Sized")]
91 #[stable(feature = "rust1", since = "1.0.0")]
93 #[rustc_on_unimplemented(
94 message = "the size for values of type `{Self}` cannot be known at compilation time",
95 label = "doesn't have a size known at compile-time"
97 #[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
98 #[rustc_specialization_trait]
99 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
104 /// Types that can be "unsized" to a dynamically-sized type.
106 /// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>` and
107 /// `Unsize<dyn fmt::Debug>`.
109 /// All implementations of `Unsize` are provided automatically by the compiler.
110 /// Those implementations are:
112 /// - Arrays `[T; N]` implement `Unsize<[T]>`.
113 /// - Types implementing a trait `Trait` also implement `Unsize<dyn Trait>`.
114 /// - Structs `Foo<..., T, ...>` implement `Unsize<Foo<..., U, ...>>` if all of these conditions
116 /// - `T: Unsize<U>`.
117 /// - Only the last field of `Foo` has a type involving `T`.
118 /// - `Bar<T>: Unsize<Bar<U>>`, where `Bar<T>` stands for the actual type of that last field.
120 /// `Unsize` is used along with [`ops::CoerceUnsized`] to allow
121 /// "user-defined" containers such as [`Rc`] to contain dynamically-sized
122 /// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on coercion][nomicon-coerce]
123 /// for more details.
125 /// [`ops::CoerceUnsized`]: crate::ops::CoerceUnsized
126 /// [`Rc`]: ../../std/rc/struct.Rc.html
127 /// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
128 /// [nomicon-coerce]: ../../nomicon/coercions.html
129 #[unstable(feature = "unsize", issue = "27732")]
131 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
132 pub trait Unsize<T: ?Sized> {
136 /// Required trait for constants used in pattern matches.
138 /// Any type that derives `PartialEq` automatically implements this trait,
139 /// *regardless* of whether its type-parameters implement `Eq`.
141 /// If a `const` item contains some type that does not implement this trait,
142 /// then that type either (1.) does not implement `PartialEq` (which means the
143 /// constant will not provide that comparison method, which code generation
144 /// assumes is available), or (2.) it implements *its own* version of
145 /// `PartialEq` (which we assume does not conform to a structural-equality
148 /// In either of the two scenarios above, we reject usage of such a constant in
151 /// See also the [structural match RFC][RFC1445], and [issue 63438] which
152 /// motivated migrating from attribute-based design to this trait.
154 /// [RFC1445]: https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-in-patterns.md
155 /// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
156 #[unstable(feature = "structural_match", issue = "31434")]
157 #[rustc_on_unimplemented(message = "the type `{Self}` does not `#[derive(PartialEq)]`")]
158 #[lang = "structural_peq"]
159 pub trait StructuralPartialEq {
163 /// Required trait for constants used in pattern matches.
165 /// Any type that derives `Eq` automatically implements this trait, *regardless*
166 /// of whether its type parameters implement `Eq`.
168 /// This is a hack to work around a limitation in our type system.
172 /// We want to require that types of consts used in pattern matches
173 /// have the attribute `#[derive(PartialEq, Eq)]`.
175 /// In a more ideal world, we could check that requirement by just checking that
176 /// the given type implements both the `StructuralPartialEq` trait *and*
177 /// the `Eq` trait. However, you can have ADTs that *do* `derive(PartialEq, Eq)`,
178 /// and be a case that we want the compiler to accept, and yet the constant's
179 /// type fails to implement `Eq`.
181 /// Namely, a case like this:
184 /// #[derive(PartialEq, Eq)]
185 /// struct Wrap<X>(X);
187 /// fn higher_order(_: &()) { }
189 /// const CFN: Wrap<fn(&())> = Wrap(higher_order);
199 /// (The problem in the above code is that `Wrap<fn(&())>` does not implement
200 /// `PartialEq`, nor `Eq`, because `for<'a> fn(&'a _)` does not implement those
203 /// Therefore, we cannot rely on naive check for `StructuralPartialEq` and
206 /// As a hack to work around this, we use two separate traits injected by each
207 /// of the two derives (`#[derive(PartialEq)]` and `#[derive(Eq)]`) and check
208 /// that both of them are present as part of structural-match checking.
209 #[unstable(feature = "structural_match", issue = "31434")]
210 #[rustc_on_unimplemented(message = "the type `{Self}` does not `#[derive(Eq)]`")]
211 #[lang = "structural_teq"]
212 pub trait StructuralEq {
216 /// Types whose values can be duplicated simply by copying bits.
218 /// By default, variable bindings have 'move semantics.' In other
229 /// // `x` has moved into `y`, and so cannot be used
231 /// // println!("{x:?}"); // error: use of moved value
234 /// However, if a type implements `Copy`, it instead has 'copy semantics':
237 /// // We can derive a `Copy` implementation. `Clone` is also required, as it's
238 /// // a supertrait of `Copy`.
239 /// #[derive(Debug, Copy, Clone)]
246 /// // `y` is a copy of `x`
248 /// println!("{x:?}"); // A-OK!
251 /// It's important to note that in these two examples, the only difference is whether you
252 /// are allowed to access `x` after the assignment. Under the hood, both a copy and a move
253 /// can result in bits being copied in memory, although this is sometimes optimized away.
255 /// ## How can I implement `Copy`?
257 /// There are two ways to implement `Copy` on your type. The simplest is to use `derive`:
260 /// #[derive(Copy, Clone)]
264 /// You can also implement `Copy` and `Clone` manually:
269 /// impl Copy for MyStruct { }
271 /// impl Clone for MyStruct {
272 /// fn clone(&self) -> MyStruct {
278 /// There is a small difference between the two: the `derive` strategy will also place a `Copy`
279 /// bound on type parameters, which isn't always desired.
281 /// ## What's the difference between `Copy` and `Clone`?
283 /// Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of
284 /// `Copy` is not overloadable; it is always a simple bit-wise copy.
286 /// Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can
287 /// provide any type-specific behavior necessary to duplicate values safely. For example,
288 /// the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string
289 /// buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the
290 /// pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]
293 /// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement
294 /// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`
295 /// (see the example above).
297 /// ## When can my type be `Copy`?
299 /// A type can implement `Copy` if all of its components implement `Copy`. For example, this
300 /// struct can be `Copy`:
303 /// # #[allow(dead_code)]
304 /// #[derive(Copy, Clone)]
311 /// A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`.
312 /// By contrast, consider
315 /// # #![allow(dead_code)]
317 /// struct PointList {
318 /// points: Vec<Point>,
322 /// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we
323 /// attempt to derive a `Copy` implementation, we'll get an error:
326 /// the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`
329 /// Shared references (`&T`) are also `Copy`, so a type can be `Copy`, even when it holds
330 /// shared references of types `T` that are *not* `Copy`. Consider the following struct,
331 /// which can implement `Copy`, because it only holds a *shared reference* to our non-`Copy`
332 /// type `PointList` from above:
335 /// # #![allow(dead_code)]
336 /// # struct PointList;
337 /// #[derive(Copy, Clone)]
338 /// struct PointListWrapper<'a> {
339 /// point_list_ref: &'a PointList,
343 /// ## When *can't* my type be `Copy`?
345 /// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
346 /// mutable reference. Copying [`String`] would duplicate responsibility for managing the
347 /// [`String`]'s buffer, leading to a double free.
349 /// Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's
350 /// managing some resource besides its own [`size_of::<T>`] bytes.
352 /// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get
353 /// the error [E0204].
355 /// [E0204]: ../../error_codes/E0204.html
357 /// ## When *should* my type be `Copy`?
359 /// Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,
360 /// that implementing `Copy` is part of the public API of your type. If the type might become
361 /// non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to
362 /// avoid a breaking API change.
364 /// ## Additional implementors
366 /// In addition to the [implementors listed below][impls],
367 /// the following types also implement `Copy`:
369 /// * Function item types (i.e., the distinct types defined for each function)
370 /// * Function pointer types (e.g., `fn() -> i32`)
371 /// * Closure types, if they capture no value from the environment
372 /// or if all such captured values implement `Copy` themselves.
373 /// Note that variables captured by shared reference always implement `Copy`
374 /// (even if the referent doesn't),
375 /// while variables captured by mutable reference never implement `Copy`.
377 /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
378 /// [`String`]: ../../std/string/struct.String.html
379 /// [`size_of::<T>`]: crate::mem::size_of
380 /// [impls]: #implementors
381 #[stable(feature = "rust1", since = "1.0.0")]
383 // FIXME(matthewjasper) This allows copying a type that doesn't implement
384 // `Copy` because of unsatisfied lifetime bounds (copying `A<'_>` when only
385 // `A<'static>: Copy` and `A<'_>: Clone`).
386 // We have this attribute here for now only because there are quite a few
387 // existing specializations on `Copy` that already exist in the standard
388 // library, and there's no way to safely have this behavior right now.
389 #[rustc_unsafe_specialization_marker]
390 #[rustc_diagnostic_item = "Copy"]
391 pub trait Copy: Clone {
395 /// Derive macro generating an impl of the trait `Copy`.
396 #[rustc_builtin_macro]
397 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
398 #[allow_internal_unstable(core_intrinsics, derive_clone_copy)]
399 pub macro Copy($item:item) {
400 /* compiler built-in */
403 /// Types for which it is safe to share references between threads.
405 /// This trait is automatically implemented when the compiler determines
406 /// it's appropriate.
408 /// The precise definition is: a type `T` is [`Sync`] if and only if `&T` is
409 /// [`Send`]. In other words, if there is no possibility of
410 /// [undefined behavior][ub] (including data races) when passing
411 /// `&T` references between threads.
413 /// As one would expect, primitive types like [`u8`] and [`f64`]
414 /// are all [`Sync`], and so are simple aggregate types containing them,
415 /// like tuples, structs and enums. More examples of basic [`Sync`]
416 /// types include "immutable" types like `&T`, and those with simple
417 /// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and
418 /// most other collection types. (Generic parameters need to be [`Sync`]
419 /// for their container to be [`Sync`].)
421 /// A somewhat surprising consequence of the definition is that `&mut T`
422 /// is `Sync` (if `T` is `Sync`) even though it seems like that might
423 /// provide unsynchronized mutation. The trick is that a mutable
424 /// reference behind a shared reference (that is, `& &mut T`)
425 /// becomes read-only, as if it were a `& &T`. Hence there is no risk
428 /// Types that are not `Sync` are those that have "interior
429 /// mutability" in a non-thread-safe form, such as [`Cell`][cell]
430 /// and [`RefCell`][refcell]. These types allow for mutation of
431 /// their contents even through an immutable, shared reference. For
432 /// example the `set` method on [`Cell<T>`][cell] takes `&self`, so it requires
433 /// only a shared reference [`&Cell<T>`][cell]. The method performs no
434 /// synchronization, thus [`Cell`][cell] cannot be `Sync`.
436 /// Another example of a non-`Sync` type is the reference-counting
437 /// pointer [`Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone
438 /// a new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way.
440 /// For cases when one does need thread-safe interior mutability,
441 /// Rust provides [atomic data types], as well as explicit locking via
442 /// [`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types
443 /// ensure that any mutation cannot cause data races, hence the types
444 /// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe
445 /// analogue of [`Rc`][rc].
447 /// Any types with interior mutability must also use the
448 /// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which
449 /// can be mutated through a shared reference. Failing to doing this is
450 /// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing
451 /// from `&T` to `&mut T` is invalid.
453 /// See [the Nomicon][nomicon-send-and-sync] for more details about `Sync`.
455 /// [box]: ../../std/boxed/struct.Box.html
456 /// [vec]: ../../std/vec/struct.Vec.html
457 /// [cell]: crate::cell::Cell
458 /// [refcell]: crate::cell::RefCell
459 /// [rc]: ../../std/rc/struct.Rc.html
460 /// [arc]: ../../std/sync/struct.Arc.html
461 /// [atomic data types]: crate::sync::atomic
462 /// [mutex]: ../../std/sync/struct.Mutex.html
463 /// [rwlock]: ../../std/sync/struct.RwLock.html
464 /// [unsafecell]: crate::cell::UnsafeCell
465 /// [ub]: ../../reference/behavior-considered-undefined.html
466 /// [transmute]: crate::mem::transmute
467 /// [nomicon-send-and-sync]: ../../nomicon/send-and-sync.html
468 #[stable(feature = "rust1", since = "1.0.0")]
469 #[cfg_attr(not(test), rustc_diagnostic_item = "Sync")]
471 #[rustc_on_unimplemented(
472 message = "`{Self}` cannot be shared between threads safely",
473 label = "`{Self}` cannot be shared between threads safely"
475 pub unsafe auto trait Sync {
476 // FIXME(estebank): once support to add notes in `rustc_on_unimplemented`
477 // lands in beta, and it has been extended to check whether a closure is
478 // anywhere in the requirement chain, extend it as such (#48534):
482 // note="`{Self}` cannot be shared safely, consider marking the closure `move`"
489 #[stable(feature = "rust1", since = "1.0.0")]
490 impl<T: ?Sized> !Sync for *const T {}
491 #[stable(feature = "rust1", since = "1.0.0")]
492 impl<T: ?Sized> !Sync for *mut T {}
494 /// Zero-sized type used to mark things that "act like" they own a `T`.
496 /// Adding a `PhantomData<T>` field to your type tells the compiler that your
497 /// type acts as though it stores a value of type `T`, even though it doesn't
498 /// really. This information is used when computing certain safety properties.
500 /// For a more in-depth explanation of how to use `PhantomData<T>`, please see
501 /// [the Nomicon](../../nomicon/phantom-data.html).
503 /// # A ghastly note 👻👻👻
505 /// Though they both have scary names, `PhantomData` and 'phantom types' are
506 /// related, but not identical. A phantom type parameter is simply a type
507 /// parameter which is never used. In Rust, this often causes the compiler to
508 /// complain, and the solution is to add a "dummy" use by way of `PhantomData`.
512 /// ## Unused lifetime parameters
514 /// Perhaps the most common use case for `PhantomData` is a struct that has an
515 /// unused lifetime parameter, typically as part of some unsafe code. For
516 /// example, here is a struct `Slice` that has two pointers of type `*const T`,
517 /// presumably pointing into an array somewhere:
519 /// ```compile_fail,E0392
520 /// struct Slice<'a, T> {
526 /// The intention is that the underlying data is only valid for the
527 /// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
528 /// intent is not expressed in the code, since there are no uses of
529 /// the lifetime `'a` and hence it is not clear what data it applies
530 /// to. We can correct this by telling the compiler to act *as if* the
531 /// `Slice` struct contained a reference `&'a T`:
534 /// use std::marker::PhantomData;
536 /// # #[allow(dead_code)]
537 /// struct Slice<'a, T: 'a> {
540 /// phantom: PhantomData<&'a T>,
544 /// This also in turn requires the annotation `T: 'a`, indicating
545 /// that any references in `T` are valid over the lifetime `'a`.
547 /// When initializing a `Slice` you simply provide the value
548 /// `PhantomData` for the field `phantom`:
551 /// # #![allow(dead_code)]
552 /// # use std::marker::PhantomData;
553 /// # struct Slice<'a, T: 'a> {
554 /// # start: *const T,
556 /// # phantom: PhantomData<&'a T>,
558 /// fn borrow_vec<T>(vec: &Vec<T>) -> Slice<'_, T> {
559 /// let ptr = vec.as_ptr();
562 /// end: unsafe { ptr.add(vec.len()) },
563 /// phantom: PhantomData,
568 /// ## Unused type parameters
570 /// It sometimes happens that you have unused type parameters which
571 /// indicate what type of data a struct is "tied" to, even though that
572 /// data is not actually found in the struct itself. Here is an
573 /// example where this arises with [FFI]. The foreign interface uses
574 /// handles of type `*mut ()` to refer to Rust values of different
575 /// types. We track the Rust type using a phantom type parameter on
576 /// the struct `ExternalResource` which wraps a handle.
578 /// [FFI]: ../../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
581 /// # #![allow(dead_code)]
582 /// # trait ResType { }
583 /// # struct ParamType;
584 /// # mod foreign_lib {
585 /// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
586 /// # pub fn do_stuff(_: *mut (), _: usize) {}
588 /// # fn convert_params(_: ParamType) -> usize { 42 }
589 /// use std::marker::PhantomData;
592 /// struct ExternalResource<R> {
593 /// resource_handle: *mut (),
594 /// resource_type: PhantomData<R>,
597 /// impl<R: ResType> ExternalResource<R> {
598 /// fn new() -> Self {
599 /// let size_of_res = mem::size_of::<R>();
601 /// resource_handle: foreign_lib::new(size_of_res),
602 /// resource_type: PhantomData,
606 /// fn do_stuff(&self, param: ParamType) {
607 /// let foreign_params = convert_params(param);
608 /// foreign_lib::do_stuff(self.resource_handle, foreign_params);
613 /// ## Ownership and the drop check
615 /// Adding a field of type `PhantomData<T>` indicates that your
616 /// type owns data of type `T`. This in turn implies that when your
617 /// type is dropped, it may drop one or more instances of the type
618 /// `T`. This has bearing on the Rust compiler's [drop check]
621 /// If your struct does not in fact *own* the data of type `T`, it is
622 /// better to use a reference type, like `PhantomData<&'a T>`
623 /// (ideally) or `PhantomData<*const T>` (if no lifetime applies), so
624 /// as not to indicate ownership.
626 /// [drop check]: ../../nomicon/dropck.html
627 #[lang = "phantom_data"]
628 #[stable(feature = "rust1", since = "1.0.0")]
629 pub struct PhantomData<T: ?Sized>;
631 #[stable(feature = "rust1", since = "1.0.0")]
632 impl<T: ?Sized> Hash for PhantomData<T> {
634 fn hash<H: Hasher>(&self, _: &mut H) {}
637 #[stable(feature = "rust1", since = "1.0.0")]
638 impl<T: ?Sized> cmp::PartialEq for PhantomData<T> {
639 fn eq(&self, _other: &PhantomData<T>) -> bool {
644 #[stable(feature = "rust1", since = "1.0.0")]
645 impl<T: ?Sized> cmp::Eq for PhantomData<T> {}
647 #[stable(feature = "rust1", since = "1.0.0")]
648 impl<T: ?Sized> cmp::PartialOrd for PhantomData<T> {
649 fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<cmp::Ordering> {
650 Option::Some(cmp::Ordering::Equal)
654 #[stable(feature = "rust1", since = "1.0.0")]
655 impl<T: ?Sized> cmp::Ord for PhantomData<T> {
656 fn cmp(&self, _other: &PhantomData<T>) -> cmp::Ordering {
661 #[stable(feature = "rust1", since = "1.0.0")]
662 impl<T: ?Sized> Copy for PhantomData<T> {}
664 #[stable(feature = "rust1", since = "1.0.0")]
665 impl<T: ?Sized> Clone for PhantomData<T> {
666 fn clone(&self) -> Self {
671 #[stable(feature = "rust1", since = "1.0.0")]
672 #[rustc_const_unstable(feature = "const_default_impls", issue = "87864")]
673 impl<T: ?Sized> const Default for PhantomData<T> {
674 fn default() -> Self {
679 #[unstable(feature = "structural_match", issue = "31434")]
680 impl<T: ?Sized> StructuralPartialEq for PhantomData<T> {}
682 #[unstable(feature = "structural_match", issue = "31434")]
683 impl<T: ?Sized> StructuralEq for PhantomData<T> {}
685 /// Compiler-internal trait used to indicate the type of enum discriminants.
687 /// This trait is automatically implemented for every type and does not add any
688 /// guarantees to [`mem::Discriminant`]. It is **undefined behavior** to transmute
689 /// between `DiscriminantKind::Discriminant` and `mem::Discriminant`.
691 /// [`mem::Discriminant`]: crate::mem::Discriminant
693 feature = "discriminant_kind",
695 reason = "this trait is unlikely to ever be stabilized, use `mem::discriminant` instead"
697 #[lang = "discriminant_kind"]
698 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
699 pub trait DiscriminantKind {
700 /// The type of the discriminant, which must satisfy the trait
701 /// bounds required by `mem::Discriminant`.
702 #[lang = "discriminant_type"]
703 type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Send + Sync + Unpin;
706 /// Compiler-internal trait used to determine whether a type contains
707 /// any `UnsafeCell` internally, but not through an indirection.
708 /// This affects, for example, whether a `static` of that type is
709 /// placed in read-only static memory or writable static memory.
711 pub(crate) unsafe auto trait Freeze {}
713 impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
714 unsafe impl<T: ?Sized> Freeze for PhantomData<T> {}
715 unsafe impl<T: ?Sized> Freeze for *const T {}
716 unsafe impl<T: ?Sized> Freeze for *mut T {}
717 unsafe impl<T: ?Sized> Freeze for &T {}
718 unsafe impl<T: ?Sized> Freeze for &mut T {}
720 /// Types that can be safely moved after being pinned.
722 /// Rust itself has no notion of immovable types, and considers moves (e.g.,
723 /// through assignment or [`mem::replace`]) to always be safe.
725 /// The [`Pin`][Pin] type is used instead to prevent moves through the type
726 /// system. Pointers `P<T>` wrapped in the [`Pin<P<T>>`][Pin] wrapper can't be
727 /// moved out of. See the [`pin` module] documentation for more information on
730 /// Implementing the `Unpin` trait for `T` lifts the restrictions of pinning off
731 /// the type, which then allows moving `T` out of [`Pin<P<T>>`][Pin] with
732 /// functions such as [`mem::replace`].
734 /// `Unpin` has no consequence at all for non-pinned data. In particular,
735 /// [`mem::replace`] happily moves `!Unpin` data (it works for any `&mut T`, not
736 /// just when `T: Unpin`). However, you cannot use [`mem::replace`] on data
737 /// wrapped inside a [`Pin<P<T>>`][Pin] because you cannot get the `&mut T` you
738 /// need for that, and *that* is what makes this system work.
740 /// So this, for example, can only be done on types implementing `Unpin`:
743 /// # #![allow(unused_must_use)]
745 /// use std::pin::Pin;
747 /// let mut string = "this".to_string();
748 /// let mut pinned_string = Pin::new(&mut string);
750 /// // We need a mutable reference to call `mem::replace`.
751 /// // We can obtain such a reference by (implicitly) invoking `Pin::deref_mut`,
752 /// // but that is only possible because `String` implements `Unpin`.
753 /// mem::replace(&mut *pinned_string, "other".to_string());
756 /// This trait is automatically implemented for almost every type.
758 /// [`mem::replace`]: crate::mem::replace
759 /// [Pin]: crate::pin::Pin
760 /// [`pin` module]: crate::pin
761 #[stable(feature = "pin", since = "1.33.0")]
762 #[rustc_on_unimplemented(
763 note = "consider using `Box::pin`",
764 message = "`{Self}` cannot be unpinned"
767 pub auto trait Unpin {}
769 /// A marker type which does not implement `Unpin`.
771 /// If a type contains a `PhantomPinned`, it will not implement `Unpin` by default.
772 #[stable(feature = "pin", since = "1.33.0")]
773 #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
774 pub struct PhantomPinned;
776 #[stable(feature = "pin", since = "1.33.0")]
777 impl !Unpin for PhantomPinned {}
779 #[stable(feature = "pin", since = "1.33.0")]
780 impl<'a, T: ?Sized + 'a> Unpin for &'a T {}
782 #[stable(feature = "pin", since = "1.33.0")]
783 impl<'a, T: ?Sized + 'a> Unpin for &'a mut T {}
785 #[stable(feature = "pin_raw", since = "1.38.0")]
786 impl<T: ?Sized> Unpin for *const T {}
788 #[stable(feature = "pin_raw", since = "1.38.0")]
789 impl<T: ?Sized> Unpin for *mut T {}
791 /// A marker for types that can be dropped.
793 /// This should be used for `~const` bounds,
794 /// as non-const bounds will always hold for every type.
795 #[unstable(feature = "const_trait_impl", issue = "67792")]
797 #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
799 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
800 pub trait Destruct {}
802 /// A marker for tuple types.
804 /// The implementation of this trait is built-in and cannot be implemented
805 /// for any user type.
806 #[unstable(feature = "tuple_trait", issue = "none")]
807 #[lang = "tuple_trait"]
808 #[rustc_on_unimplemented(message = "`{Self}` is not a tuple")]
809 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
812 /// A marker for things
813 #[unstable(feature = "pointer_sized_trait", issue = "none")]
814 #[cfg_attr(not(bootstrap), lang = "pointer_sized")]
815 #[rustc_on_unimplemented(
816 message = "`{Self}` needs to be a pointer-sized type",
817 label = "`{Self}` needs to be a pointer-sized type"
819 pub trait PointerSized {}
821 /// Implementations of `Copy` for primitive types.
823 /// Implementations that cannot be described in Rust
824 /// are implemented in `traits::SelectionContext::copy_clone_conditions()`
825 /// in `rustc_trait_selection`.
830 macro_rules! impl_copy {
833 #[stable(feature = "rust1", since = "1.0.0")]
840 usize u8 u16 u32 u64 u128
841 isize i8 i16 i32 i64 i128
846 #[unstable(feature = "never_type", issue = "35121")]
849 #[stable(feature = "rust1", since = "1.0.0")]
850 impl<T: ?Sized> Copy for *const T {}
852 #[stable(feature = "rust1", since = "1.0.0")]
853 impl<T: ?Sized> Copy for *mut T {}
855 /// Shared references can be copied, but mutable references *cannot*!
856 #[stable(feature = "rust1", since = "1.0.0")]
857 impl<T: ?Sized> Copy for &T {}