# Trait std::marker::Copy 1.0.0[−][src]

    #[lang = "copy"]
    pub trait Copy: Clone { }

Types whose values can be duplicated simply by copying bits.

By default, variable bindings have 'move semantics.' In other words:

    #[derive(Debug)]
    struct Foo;

    let x = Foo;

    let y = x;

    // `x` has moved into `y`, and so cannot be used

    // println!("{:?}", x); // error: use of moved valueRun

However, if a type implements `Copy`, it instead has 'copy semantics':

    // We can derive a `Copy` implementation. `Clone` is also required, as it's
    // a supertrait of `Copy`.
    #[derive(Debug, Copy, Clone)]
    struct Foo;

    let x = Foo;

    let y = x;

    // `y` is a copy of `x`

    println!("{:?}", x); // A-OK!Run

It's important to note that in these two examples, the only difference is whether you are allowed to access `x` after the assignment. Under the hood, both a copy and a move can result in bits being copied in memory, although this is sometimes optimized away.

## How can I implement `Copy`?

There are two ways to implement `Copy` on your type. The simplest is to use `derive`:

    #[derive(Copy, Clone)]
    struct MyStruct;Run

You can also implement `Copy` and `Clone` manually:

    struct MyStruct;

    impl Copy for MyStruct { }

    impl Clone for MyStruct {
        fn clone(&self) -> MyStruct {
            *self
        }
    }Run

There is a small difference between the two: the `derive` strategy will also place a `Copy` bound on type parameters, which isn't always desired.

## What's the difference between `Copy` and `Clone`?

Copies happen implicitly, for example as part of an assignment `y = x`. The behavior of `Copy` is not overloadable; it is always a simple bit-wise copy.

Cloning is an explicit action, `x.clone()`. The implementation of `Clone` can provide any type-specific behavior necessary to duplicate values safely. For example, the implementation of `Clone` for `String` needs to copy the pointed-to string buffer in the heap. A simple bitwise copy of `String` values would merely copy the pointer, leading to a double free down the line. For this reason, `String` is `Clone` but not `Copy`.

`Clone` is a supertrait of `Copy`, so everything which is `Copy` must also implement `Clone`. If a type is `Copy` then its `Clone` implementation only needs to return `*self` (see the example above).

## When can my type be `Copy`?

A type can implement `Copy` if all of its components implement `Copy`. For example, this struct can be `Copy`:

    struct Point {
       x: i32,
       y: i32,
    }Run

A struct can be `Copy`, and `i32` is `Copy`, therefore `Point` is eligible to be `Copy`. By contrast, consider

    struct PointList {
        points: Vec<Point>,
    }Run

The struct `PointList` cannot implement `Copy`, because `Vec<T>` is not `Copy`. If we attempt to derive a `Copy` implementation, we'll get an error:

    the trait `Copy` may not be implemented for this type; field `points` does not implement `Copy`

## When can't my type be `Copy`?

Some types can't be copied safely. For example, copying `&mut T` would create an aliased mutable reference. Copying `String` would duplicate responsibility for managing the `String`'s buffer, leading to a double free.

Generalizing the latter case, any type implementing `Drop` can't be `Copy`, because it's managing some resource besides its own `size_of::<T>` bytes.

If you try to implement `Copy` on a struct or enum containing non-`Copy` data, you will get the error E0204.

## When should my type be `Copy`?

Generally speaking, if your type can implement `Copy`, it should. Keep in mind, though, that implementing `Copy` is part of the public API of your type. If the type might become non-`Copy` in the future, it could be prudent to omit the `Copy` implementation now, to avoid a breaking API change.

## Additional implementors

In addition to the implementors listed below, the following types also implement `Copy`:

- Function item types (i.e. the distinct types defined for each function)
- Function pointer types (e.g. `fn() -> i32`)
- Array types, for all sizes, if the item type also implements `Copy` (e.g. `[i32; 123456]`)
- Tuple types, if each component also implements `Copy` (e.g. `()`, `(i32, bool)`)
- Closure types, if they capture no value from the environment or if all such captured values implement `Copy` themselves. Note that variables captured by shared reference always implement `Copy` (even if the referent doesn't), while variables captured by mutable reference never implement `Copy`.

## Implementations on Foreign Types

###

`impl Copy for Layout`

[src]

###

`impl Copy for TryFromSliceError`

[src]

## Implementors

- `impl<'a> Copy for Arguments<'a>` | [src]

- `impl Copy for i8` | [src]

- `impl Copy for i64x2` | [src]

- `impl Copy for m8x16` | [src]

- `impl Copy for i8x2` | [src]

- `impl Copy for i8x32` | [src]

- `impl Copy for NoneError` | [src]

- `impl<T> Copy for Discriminant<T>` | [src]

- `impl Copy for i32x2` | [src]

- `impl<F> Copy for RepeatWith<F> where F: Copy,` | [src]

- `impl Copy for char` | [src]

- `impl Copy for f32x16` | [src]

- `impl Copy for u128` | [src]

- `impl Copy for u8x32` | [src]

- `impl Copy for m64x4` | [src]

- `impl<Y, R> Copy for GeneratorState<Y, R> where R: Copy, Y: Copy,` | [src]

- `impl<Idx> Copy for RangeToInclusive<Idx> where Idx: Copy,` | [src]

- `impl Copy for m8x8` | [src]

- `impl Copy for u64x4` | [src]

- `impl Copy for TryFromIntError` | [src]

- `impl Copy for UnicodeVersion` | [src]

- `impl Copy for TraitObject` | [src]

- `impl Copy for std::sync::atomic::Ordering` | [src]

- `impl Copy for u8x2` | [src]

- `impl Copy for isize` | [src]

- `impl Copy for f64x2` | [src]

- `impl Copy for NonZeroU8` | [src]

- `impl<T, E> Copy for Result<T, E> where E: Copy, T: Copy,` | [src]

- `impl Copy for u32x2` | [src]

- `impl Copy for i8x4` | [src]

- `impl Copy for RangeFull` | [src]

- `impl Copy for u16x4` | [src]

- `impl Copy for i16x4` | [src]

- `impl Copy for m32x4` | [src]

- `impl<T> Copy for ManuallyDrop<T> where T: Copy,` | [src]

- `impl Copy for m32x2` | [src]

- `impl Copy for u8` | [src]

- `impl Copy for NonZeroU64` | [src]

- `impl Copy for i16x2` | [src]

- `impl Copy for Duration` | [src]

- `impl Copy for u16x32` | [src]

- `impl Copy for u8x64` | [src]

- `impl<T> Copy for PhantomData<T> where T: ?Sized,` | [src]

- `impl Copy for i64` | [src]

- `impl Copy for m1x32` | [src]

- `impl Copy for u32x16` | [src]

- `impl Copy for u64x8` | [src]

- `impl Copy for m1x8` | [src]

- `impl Copy for m16x2` | [src]

- `impl Copy for NonZeroUsize` | [src]

- `impl Copy for u8x16` | [src]

- `impl Copy for Pinned` | [src]

- `impl Copy for u8x8` | [src]

- `impl Copy for Error` | [src]

- `impl<'a, T> Copy for &'a T where T: ?Sized,` | [src]

- `impl Copy for u32x8` | [src]

- `impl Copy for m16x16` | [src]

- `impl Copy for i8x8` | [src]

- `impl<T> Copy for Bound<T> where T: Copy,` | [src]

- `impl Copy for NonZeroU32` | [src]

- `impl Copy for i32x8` | [src]

- `impl Copy for m1x16` | [src]

- `impl Copy for u8x4` | [src]

- `impl Copy for bool` | [src]

- `impl Copy for m8x2` | [src]

- `impl Copy for u32x4` | [src]

- `impl Copy for u64x2` | [src]

- `impl<T> Copy for NonNull<T> where T: ?Sized,` | [src]

- `impl<T> Copy for *const T where T: ?Sized,` | [src]

- `impl Copy for i64x4` | [src]

- `impl Copy for f64` | [src]

- `impl Copy for i16x16` | [src]

- `impl Copy for std::cmp::Ordering` | [src]

- `impl<T> Copy for Option<T> where T: Copy,` | [src]

- `impl Copy for i128` | [src]

- `impl Copy for NonZeroU16` | [src]

- `impl Copy for u32` | [src]

- `impl Copy for usize` | [src]

- `impl Copy for f32x4` | [src]

- `impl Copy for f32` | [src]

- `impl Copy for Utf8Error` | [src]

- `impl Copy for !` | [src]

- `impl Copy for SearchStep` | [src]

- `impl Copy for u16x2` | [src]

- `impl Copy for FpCategory` | [src]

- `impl Copy for i32x4` | [src]

- `impl Copy for m8x32` | [src]

- `impl Copy for u16` | [src]

- `impl Copy for f64x8` | [src]

- `impl Copy for i16` | [src]

- `impl Copy for i8x64` | [src]

- `impl Copy for m16x4` | [src]

- `impl<T> Copy for Reverse<T> where T: Copy,` | [src]

- `impl<Idx> Copy for RangeTo<Idx> where Idx: Copy,` | [src]

- `impl Copy for u64` | [src]

- `impl Copy for m64x2` | [src]

- `impl Copy for i16x32` | [src]

- `impl Copy for i8x16` | [src]

- `impl Copy for i32` | [src]

- `impl Copy for i16x8` | [src]

- `impl Copy for f32x2` | [src]

- `impl Copy for m32x8` | [src]

- `impl Copy for NonZeroU128` | [src]

- `impl<T> Copy for Wrapping<T> where T: Copy,` | [src]

- `impl Copy for m1x64` | [src]

- `impl Copy for u16x16` | [src]

- `impl Copy for f32x8` | [src]

- `impl Copy for m8x4` | [src]

- `impl<T> Copy for *mut T where T: ?Sized,` | [src]

- `impl Copy for i32x16` | [src]

- `impl Copy for TypeId` | [src]

- `impl Copy for i64x8` | [src]

- `impl Copy for u16x8` | [src]

- `impl Copy for CharTryFromError` | [src]

- `impl Copy for m16x8` | [src]

- `impl Copy for f64x4` | [src]

- `impl Copy for Global` | [src]

- `impl Copy for ParseError` | [src]

- `impl Copy for ThreadId` | [src]

- `impl Copy for FileType` | [src]

- `impl Copy for ErrorKind` | [src]

- `impl Copy for SeekFrom` | [src]

- `impl Copy for IpAddr` | [src]

- `impl Copy for Ipv4Addr` | [src]

- `impl Copy for Ipv6Addr` | [src]

- `impl Copy for Ipv6MulticastScope` | [src]

- `impl Copy for SocketAddr` | [src]

- `impl Copy for SocketAddrV4` | [src]

- `impl Copy for SocketAddrV6` | [src]

- `impl Copy for Shutdown` | [src]

- `impl<'a> Copy for Prefix<'a>` | [src]

- `impl<'a> Copy for PrefixComponent<'a>` | [src]

- `impl<'a> Copy for Component<'a>` | [src]

- `impl<'a> Copy for Ancestors<'a>` | [src]

- `impl Copy for ExitStatus` | [src]

- `impl Copy for ExitCode` | [src]

- `impl<T: Copy> Copy for SendError<T>` | [src]

- `impl Copy for RecvError` | [src]

- `impl Copy for TryRecvError` | [src]

- `impl Copy for RecvTimeoutError` | [src]

- `impl<T: Copy> Copy for TrySendError<T>` | [src]

- `impl Copy for WaitTimeoutResult` | [src]

- `impl Copy for Instant` | [src]

- `impl Copy for SystemTime` | [src]

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)