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 types representing basic properties of types.
13 //! Rust types can be classified in various useful ways according to
14 //! their intrinsic properties. These classifications are represented
17 #![stable(feature = "rust1", since = "1.0.0")]
24 /// Types that can be transferred across thread boundaries.
26 /// This trait is automatically implemented when the compiler determines it's
29 /// An example of a non-`Send` type is the reference-counting pointer
30 /// [`rc::Rc`][`Rc`]. If two threads attempt to clone [`Rc`]s that point to the same
31 /// reference-counted value, they might try to update the reference count at the
32 /// same time, which is [undefined behavior][ub] because [`Rc`] doesn't use atomic
33 /// operations. Its cousin [`sync::Arc`][arc] does use atomic operations (incurring
34 /// some overhead) and thus is `Send`.
36 /// See [the Nomicon](../../nomicon/send-and-sync.html) for more details.
38 /// [`Rc`]: ../../std/rc/struct.Rc.html
39 /// [arc]: ../../std/sync/struct.Arc.html
40 /// [ub]: ../../reference/behavior-considered-undefined.html
41 #[stable(feature = "rust1", since = "1.0.0")]
42 #[rustc_on_unimplemented(
43 message="`{Self}` cannot be sent between threads safely",
44 label="`{Self}` cannot be sent between threads safely"
46 pub unsafe auto trait Send {
50 #[stable(feature = "rust1", since = "1.0.0")]
51 impl<T: ?Sized> !Send for *const T { }
52 #[stable(feature = "rust1", since = "1.0.0")]
53 impl<T: ?Sized> !Send for *mut T { }
55 /// Types with a constant size known at compile time.
57 /// All type parameters have an implicit bound of `Sized`. The special syntax
58 /// `?Sized` can be used to remove this bound if it's not appropriate.
61 /// # #![allow(dead_code)]
63 /// struct Bar<T: ?Sized>(T);
65 /// // struct FooUse(Foo<[i32]>); // error: Sized is not implemented for [i32]
66 /// struct BarUse(Bar<[i32]>); // OK
69 /// The one exception is the implicit `Self` type of a trait. A trait does not
70 /// have an implicit `Sized` bound as this is incompatible with [trait object]s
71 /// where, by definition, the trait needs to work with all possible implementors,
72 /// and thus could be any size.
74 /// Although Rust will let you bind `Sized` to a trait, you won't
75 /// be able to use it to form a trait object later:
78 /// # #![allow(unused_variables)]
80 /// trait Bar: Sized { }
83 /// impl Foo for Impl { }
84 /// impl Bar for Impl { }
86 /// let x: &Foo = &Impl; // OK
87 /// // let y: &Bar = &Impl; // error: the trait `Bar` cannot
88 /// // be made into an object
91 /// [trait object]: ../../book/first-edition/trait-objects.html
92 #[stable(feature = "rust1", since = "1.0.0")]
94 #[rustc_on_unimplemented(
95 message="the size for values of type `{Self}` cannot be known at compilation time",
96 label="doesn't have a size known at compile-time",
97 note="to learn more, visit <https://doc.rust-lang.org/book/second-edition/\
98 ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>",
100 #[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
105 /// Types that can be "unsized" to a dynamically-sized type.
107 /// For example, the sized array type `[i8; 2]` implements `Unsize<[i8]>` and
108 /// `Unsize<fmt::Debug>`.
110 /// All implementations of `Unsize` are provided automatically by the compiler.
112 /// `Unsize` is implemented for:
114 /// - `[T; N]` is `Unsize<[T]>`
115 /// - `T` is `Unsize<Trait>` when `T: Trait`
116 /// - `Foo<..., T, ...>` is `Unsize<Foo<..., U, ...>>` if:
118 /// - Foo is a struct
119 /// - Only the last field of `Foo` has a type involving `T`
120 /// - `T` is not part of the type of any other fields
121 /// - `Bar<T>: Unsize<Bar<U>>`, if the last field of `Foo` has type `Bar<T>`
123 /// `Unsize` is used along with [`ops::CoerceUnsized`][coerceunsized] to allow
124 /// "user-defined" containers such as [`rc::Rc`][rc] to contain dynamically-sized
125 /// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on coercion][nomicon-coerce]
126 /// for more details.
128 /// [coerceunsized]: ../ops/trait.CoerceUnsized.html
129 /// [rc]: ../../std/rc/struct.Rc.html
130 /// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
131 /// [nomicon-coerce]: ../../nomicon/coercions.html
132 #[unstable(feature = "unsize", issue = "27732")]
134 pub trait Unsize<T: ?Sized> {
138 /// Types whose values can be duplicated simply by copying bits.
140 /// By default, variable bindings have 'move semantics.' In other
151 /// // `x` has moved into `y`, and so cannot be used
153 /// // println!("{:?}", x); // error: use of moved value
156 /// However, if a type implements `Copy`, it instead has 'copy semantics':
159 /// // We can derive a `Copy` implementation. `Clone` is also required, as it's
160 /// // a supertrait of `Copy`.
161 /// #[derive(Debug, Copy, Clone)]
168 /// // `y` is a copy of `x`
170 /// println!("{:?}", x); // A-OK!
173 /// It's important to note that in these two examples, the only difference is whether you
174 /// are allowed to access `x` after the assignment. Under the hood, both a copy and a move
175 /// can result in bits being copied in memory, although this is sometimes optimized away.
177 /// ## How can I implement `Copy`?
179 /// There are two ways to implement `Copy` on your type. The simplest is to use `derive`:
182 /// #[derive(Copy, Clone)]
186 /// You can also implement `Copy` and `Clone` manually:
191 /// impl Copy for MyStruct { }
193 /// impl Clone for MyStruct {
194 /// fn clone(&self) -> MyStruct {
200 /// There is a small difference between the two: the `derive` strategy will also place a `Copy`
201 /// bound on type parameters, which isn't always desired.
203 /// ## What's the difference between `Copy` and `Clone`?
205 /// Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of
206 /// `Copy` is not overloadable; it is always a simple bit-wise copy.
208 /// Cloning is an explicit action, `x.clone()`. The implementation of [`Clone`] can
209 /// provide any type-specific behavior necessary to duplicate values safely. For example,
210 /// the implementation of [`Clone`] for [`String`] needs to copy the pointed-to string
211 /// buffer in the heap. A simple bitwise copy of [`String`] values would merely copy the
212 /// pointer, leading to a double free down the line. For this reason, [`String`] is [`Clone`]
215 /// [`Clone`] is a supertrait of `Copy`, so everything which is `Copy` must also implement
216 /// [`Clone`]. If a type is `Copy` then its [`Clone`] implementation only needs to return `*self`
217 /// (see the example above).
219 /// ## When can my type be `Copy`?
221 /// A type can implement `Copy` if all of its components implement `Copy`. For example, this
222 /// struct can be `Copy`:
225 /// # #[allow(dead_code)]
232 /// A struct can be `Copy`, and [`i32`] is `Copy`, therefore `Point` is eligible to be `Copy`.
233 /// By contrast, consider
236 /// # #![allow(dead_code)]
238 /// struct PointList {
239 /// points: Vec<Point>,
243 /// The struct `PointList` cannot implement `Copy`, because [`Vec<T>`] is not `Copy`. If we
244 /// attempt to derive a `Copy` implementation, we'll get an error:
247 /// the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`
250 /// ## When *can't* my type be `Copy`?
252 /// Some types can't be copied safely. For example, copying `&mut T` would create an aliased
253 /// mutable reference. Copying [`String`] would duplicate responsibility for managing the
254 /// [`String`]'s buffer, leading to a double free.
256 /// Generalizing the latter case, any type implementing [`Drop`] can't be `Copy`, because it's
257 /// managing some resource besides its own [`size_of::<T>`] bytes.
259 /// If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get
260 /// the error [E0204].
262 /// [E0204]: ../../error-index.html#E0204
264 /// ## When *should* my type be `Copy`?
266 /// Generally speaking, if your type _can_ implement `Copy`, it should. Keep in mind, though,
267 /// that implementing `Copy` is part of the public API of your type. If the type might become
268 /// non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to
269 /// avoid a breaking API change.
271 /// ## Additional implementors
273 /// In addition to the [implementors listed below][impls],
274 /// the following types also implement `Copy`:
276 /// * Function item types (i.e. the distinct types defined for each function)
277 /// * Function pointer types (e.g. `fn() -> i32`)
278 /// * Array types, for all sizes, if the item type also implements `Copy` (e.g. `[i32; 123456]`)
279 /// * Tuple types, if each component also implements `Copy` (e.g. `()`, `(i32, bool)`)
280 /// * Closure types, if they capture no value from the environment
281 /// or if all such captured values implement `Copy` themselves.
282 /// Note that variables captured by shared reference always implement `Copy`
283 /// (even if the referent doesn't),
284 /// while variables captured by mutable reference never implement `Copy`.
286 /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
287 /// [`String`]: ../../std/string/struct.String.html
288 /// [`Drop`]: ../../std/ops/trait.Drop.html
289 /// [`size_of::<T>`]: ../../std/mem/fn.size_of.html
290 /// [`Clone`]: ../clone/trait.Clone.html
291 /// [`String`]: ../../std/string/struct.String.html
292 /// [`i32`]: ../../std/primitive.i32.html
293 /// [impls]: #implementors
294 #[stable(feature = "rust1", since = "1.0.0")]
296 pub trait Copy : Clone {
300 /// Types for which it is safe to share references between threads.
302 /// This trait is automatically implemented when the compiler determines
303 /// it's appropriate.
305 /// The precise definition is: a type `T` is `Sync` if and only if `&T` is
306 /// [`Send`][send]. In other words, if there is no possibility of
307 /// [undefined behavior][ub] (including data races) when passing
308 /// `&T` references between threads.
310 /// As one would expect, primitive types like [`u8`][u8] and [`f64`][f64]
311 /// are all `Sync`, and so are simple aggregate types containing them,
312 /// like tuples, structs and enums. More examples of basic `Sync`
313 /// types include "immutable" types like `&T`, and those with simple
314 /// inherited mutability, such as [`Box<T>`][box], [`Vec<T>`][vec] and
315 /// most other collection types. (Generic parameters need to be `Sync`
316 /// for their container to be `Sync`.)
318 /// A somewhat surprising consequence of the definition is that `&mut T`
319 /// is `Sync` (if `T` is `Sync`) even though it seems like that might
320 /// provide unsynchronized mutation. The trick is that a mutable
321 /// reference behind a shared reference (that is, `& &mut T`)
322 /// becomes read-only, as if it were a `& &T`. Hence there is no risk
325 /// Types that are not `Sync` are those that have "interior
326 /// mutability" in a non-thread-safe form, such as [`cell::Cell`][cell]
327 /// and [`cell::RefCell`][refcell]. These types allow for mutation of
328 /// their contents even through an immutable, shared reference. For
329 /// example the `set` method on [`Cell<T>`][cell] takes `&self`, so it requires
330 /// only a shared reference [`&Cell<T>`][cell]. The method performs no
331 /// synchronization, thus [`Cell`][cell] cannot be `Sync`.
333 /// Another example of a non-`Sync` type is the reference-counting
334 /// pointer [`rc::Rc`][rc]. Given any reference [`&Rc<T>`][rc], you can clone
335 /// a new [`Rc<T>`][rc], modifying the reference counts in a non-atomic way.
337 /// For cases when one does need thread-safe interior mutability,
338 /// Rust provides [atomic data types], as well as explicit locking via
339 /// [`sync::Mutex`][mutex] and [`sync::RwLock`][rwlock]. These types
340 /// ensure that any mutation cannot cause data races, hence the types
341 /// are `Sync`. Likewise, [`sync::Arc`][arc] provides a thread-safe
342 /// analogue of [`Rc`][rc].
344 /// Any types with interior mutability must also use the
345 /// [`cell::UnsafeCell`][unsafecell] wrapper around the value(s) which
346 /// can be mutated through a shared reference. Failing to doing this is
347 /// [undefined behavior][ub]. For example, [`transmute`][transmute]-ing
348 /// from `&T` to `&mut T` is invalid.
350 /// See [the Nomicon](../../nomicon/send-and-sync.html) for more
351 /// details about `Sync`.
353 /// [send]: trait.Send.html
354 /// [u8]: ../../std/primitive.u8.html
355 /// [f64]: ../../std/primitive.f64.html
356 /// [box]: ../../std/boxed/struct.Box.html
357 /// [vec]: ../../std/vec/struct.Vec.html
358 /// [cell]: ../cell/struct.Cell.html
359 /// [refcell]: ../cell/struct.RefCell.html
360 /// [rc]: ../../std/rc/struct.Rc.html
361 /// [arc]: ../../std/sync/struct.Arc.html
362 /// [atomic data types]: ../sync/atomic/index.html
363 /// [mutex]: ../../std/sync/struct.Mutex.html
364 /// [rwlock]: ../../std/sync/struct.RwLock.html
365 /// [unsafecell]: ../cell/struct.UnsafeCell.html
366 /// [ub]: ../../reference/behavior-considered-undefined.html
367 /// [transmute]: ../../std/mem/fn.transmute.html
368 #[stable(feature = "rust1", since = "1.0.0")]
370 #[rustc_on_unimplemented(
371 message="`{Self}` cannot be shared between threads safely",
372 label="`{Self}` cannot be shared between threads safely"
374 pub unsafe auto trait Sync {
375 // FIXME(estebank): once support to add notes in `rustc_on_unimplemented`
376 // lands in beta, and it has been extended to check whether a closure is
377 // anywhere in the requirement chain, extend it as such (#48534):
381 // note="`{Self}` cannot be shared safely, consider marking the closure `move`"
388 #[stable(feature = "rust1", since = "1.0.0")]
389 impl<T: ?Sized> !Sync for *const T { }
390 #[stable(feature = "rust1", since = "1.0.0")]
391 impl<T: ?Sized> !Sync for *mut T { }
395 #[stable(feature = "rust1", since = "1.0.0")]
396 impl<T:?Sized> Hash for $t<T> {
398 fn hash<H: Hasher>(&self, _: &mut H) {
402 #[stable(feature = "rust1", since = "1.0.0")]
403 impl<T:?Sized> cmp::PartialEq for $t<T> {
404 fn eq(&self, _other: &$t<T>) -> bool {
409 #[stable(feature = "rust1", since = "1.0.0")]
410 impl<T:?Sized> cmp::Eq for $t<T> {
413 #[stable(feature = "rust1", since = "1.0.0")]
414 impl<T:?Sized> cmp::PartialOrd for $t<T> {
415 fn partial_cmp(&self, _other: &$t<T>) -> Option<cmp::Ordering> {
416 Option::Some(cmp::Ordering::Equal)
420 #[stable(feature = "rust1", since = "1.0.0")]
421 impl<T:?Sized> cmp::Ord for $t<T> {
422 fn cmp(&self, _other: &$t<T>) -> cmp::Ordering {
427 #[stable(feature = "rust1", since = "1.0.0")]
428 impl<T:?Sized> Copy for $t<T> { }
430 #[stable(feature = "rust1", since = "1.0.0")]
431 impl<T:?Sized> Clone for $t<T> {
432 fn clone(&self) -> $t<T> {
437 #[stable(feature = "rust1", since = "1.0.0")]
438 impl<T:?Sized> Default for $t<T> {
439 fn default() -> $t<T> {
446 /// Zero-sized type used to mark things that "act like" they own a `T`.
448 /// Adding a `PhantomData<T>` field to your type tells the compiler that your
449 /// type acts as though it stores a value of type `T`, even though it doesn't
450 /// really. This information is used when computing certain safety properties.
452 /// For a more in-depth explanation of how to use `PhantomData<T>`, please see
453 /// [the Nomicon](../../nomicon/phantom-data.html).
455 /// # A ghastly note 👻👻👻
457 /// Though they both have scary names, `PhantomData` and 'phantom types' are
458 /// related, but not identical. A phantom type parameter is simply a type
459 /// parameter which is never used. In Rust, this often causes the compiler to
460 /// complain, and the solution is to add a "dummy" use by way of `PhantomData`.
464 /// ## Unused lifetime parameters
466 /// Perhaps the most common use case for `PhantomData` is a struct that has an
467 /// unused lifetime parameter, typically as part of some unsafe code. For
468 /// example, here is a struct `Slice` that has two pointers of type `*const T`,
469 /// presumably pointing into an array somewhere:
471 /// ```compile_fail,E0392
472 /// struct Slice<'a, T> {
478 /// The intention is that the underlying data is only valid for the
479 /// lifetime `'a`, so `Slice` should not outlive `'a`. However, this
480 /// intent is not expressed in the code, since there are no uses of
481 /// the lifetime `'a` and hence it is not clear what data it applies
482 /// to. We can correct this by telling the compiler to act *as if* the
483 /// `Slice` struct contained a reference `&'a T`:
486 /// use std::marker::PhantomData;
488 /// # #[allow(dead_code)]
489 /// struct Slice<'a, T: 'a> {
492 /// phantom: PhantomData<&'a T>,
496 /// This also in turn requires the annotation `T: 'a`, indicating
497 /// that any references in `T` are valid over the lifetime `'a`.
499 /// When initializing a `Slice` you simply provide the value
500 /// `PhantomData` for the field `phantom`:
503 /// # #![allow(dead_code)]
504 /// # use std::marker::PhantomData;
505 /// # struct Slice<'a, T: 'a> {
506 /// # start: *const T,
508 /// # phantom: PhantomData<&'a T>,
510 /// fn borrow_vec<'a, T>(vec: &'a Vec<T>) -> Slice<'a, T> {
511 /// let ptr = vec.as_ptr();
514 /// end: unsafe { ptr.add(vec.len()) },
515 /// phantom: PhantomData,
520 /// ## Unused type parameters
522 /// It sometimes happens that you have unused type parameters which
523 /// indicate what type of data a struct is "tied" to, even though that
524 /// data is not actually found in the struct itself. Here is an
525 /// example where this arises with [FFI]. The foreign interface uses
526 /// handles of type `*mut ()` to refer to Rust values of different
527 /// types. We track the Rust type using a phantom type parameter on
528 /// the struct `ExternalResource` which wraps a handle.
530 /// [FFI]: ../../book/first-edition/ffi.html
533 /// # #![allow(dead_code)]
534 /// # trait ResType { }
535 /// # struct ParamType;
536 /// # mod foreign_lib {
537 /// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
538 /// # pub fn do_stuff(_: *mut (), _: usize) {}
540 /// # fn convert_params(_: ParamType) -> usize { 42 }
541 /// use std::marker::PhantomData;
544 /// struct ExternalResource<R> {
545 /// resource_handle: *mut (),
546 /// resource_type: PhantomData<R>,
549 /// impl<R: ResType> ExternalResource<R> {
550 /// fn new() -> ExternalResource<R> {
551 /// let size_of_res = mem::size_of::<R>();
552 /// ExternalResource {
553 /// resource_handle: foreign_lib::new(size_of_res),
554 /// resource_type: PhantomData,
558 /// fn do_stuff(&self, param: ParamType) {
559 /// let foreign_params = convert_params(param);
560 /// foreign_lib::do_stuff(self.resource_handle, foreign_params);
565 /// ## Ownership and the drop check
567 /// Adding a field of type `PhantomData<T>` indicates that your
568 /// type owns data of type `T`. This in turn implies that when your
569 /// type is dropped, it may drop one or more instances of the type
570 /// `T`. This has bearing on the Rust compiler's [drop check]
573 /// If your struct does not in fact *own* the data of type `T`, it is
574 /// better to use a reference type, like `PhantomData<&'a T>`
575 /// (ideally) or `PhantomData<*const T>` (if no lifetime applies), so
576 /// as not to indicate ownership.
578 /// [drop check]: ../../nomicon/dropck.html
579 #[lang = "phantom_data"]
580 #[stable(feature = "rust1", since = "1.0.0")]
581 pub struct PhantomData<T:?Sized>;
583 impls! { PhantomData }
586 #[stable(feature = "rust1", since = "1.0.0")]
587 unsafe impl<'a, T: Sync + ?Sized> Send for &'a T {}
588 #[stable(feature = "rust1", since = "1.0.0")]
589 unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {}
592 /// Compiler-internal trait used to determine whether a type contains
593 /// any `UnsafeCell` internally, but not through an indirection.
594 /// This affects, for example, whether a `static` of that type is
595 /// placed in read-only static memory or writable static memory.
597 unsafe auto trait Freeze {}
599 impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
600 unsafe impl<T: ?Sized> Freeze for PhantomData<T> {}
601 unsafe impl<T: ?Sized> Freeze for *const T {}
602 unsafe impl<T: ?Sized> Freeze for *mut T {}
603 unsafe impl<'a, T: ?Sized> Freeze for &'a T {}
604 unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {}
606 /// Types which can be safely moved after being pinned.
608 /// Since Rust itself has no notion of immovable types, and will consider moves to always be safe,
609 /// this trait cannot prevent types from moving by itself.
611 /// Instead it can be used to prevent moves through the type system,
612 /// by controlling the behavior of pointers wrapped in the [`Pin`] wrapper,
613 /// which "pin" the type in place by not allowing it to be moved out of them.
614 /// See the [`pin module`] documentation for more information on pinning.
616 /// Implementing this trait lifts the restrictions of pinning off a type,
617 /// which then allows it to move out with functions such as [`replace`].
619 /// So this, for example, can only be done on types implementing `Unpin`:
623 /// use std::mem::replace;
624 /// use std::pin::Pin;
626 /// let mut string = "this".to_string();
627 /// let mut pinned_string = Pin::new(&mut string);
629 /// // dereferencing the pointer mutably is only possible because String implements Unpin
630 /// replace(&mut *pinned_string, "other".to_string());
633 /// This trait is automatically implemented for almost every type.
635 /// [`replace`]: ../../std/mem/fn.replace.html
636 /// [`Pin`]: ../pin/struct.Pin.html
637 /// [`pin module`]: ../../std/pin/index.html
638 #[unstable(feature = "pin", issue = "49150")]
639 pub auto trait Unpin {}
641 /// A type which does not implement `Unpin`.
643 /// If a type contains a `Pinned`, it will not implement `Unpin` by default.
644 #[unstable(feature = "pin", issue = "49150")]
645 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
648 #[unstable(feature = "pin", issue = "49150")]
649 impl !Unpin for Pinned {}
651 #[unstable(feature = "pin", issue = "49150")]
652 impl<'a, T: ?Sized + 'a> Unpin for &'a T {}
654 #[unstable(feature = "pin", issue = "49150")]
655 impl<'a, T: ?Sized + 'a> Unpin for &'a mut T {}
657 /// Implementations of `Copy` for primitive types.
659 /// Implementations that cannot be described in Rust
660 /// are implemented in `SelectionContext::copy_clone_conditions()` in librustc.
665 macro_rules! impl_copy {
668 #[stable(feature = "rust1", since = "1.0.0")]
675 usize u8 u16 u32 u64 u128
676 isize i8 i16 i32 i64 i128
681 #[unstable(feature = "never_type", issue = "35121")]
684 #[stable(feature = "rust1", since = "1.0.0")]
685 impl<T: ?Sized> Copy for *const T {}
687 #[stable(feature = "rust1", since = "1.0.0")]
688 impl<T: ?Sized> Copy for *mut T {}
690 // Shared references can be copied, but mutable references *cannot*!
691 #[stable(feature = "rust1", since = "1.0.0")]
692 impl<'a, T: ?Sized> Copy for &'a T {}