# Trait core::clone::Clone 1.0.0 [−] [src]

    pub trait Clone: Sized {
        fn clone(&self) -> Self;

        fn clone_from(&mut self, source: &Self) { ... }
    }

A common trait for the ability to explicitly duplicate an object.

Differs from `Copy` in that `Copy` is implicit and extremely inexpensive, while `Clone` is always explicit and may or may not be expensive. In order to enforce these characteristics, Rust does not allow you to reimplement `Copy`, but you may reimplement `Clone` and run arbitrary code.

Since `Clone` is more general than `Copy`, you can automatically make anything `Copy` be `Clone` as well.

## Derivable

This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d implementation of `clone()` calls `clone()` on each field.

## How can I implement `Clone`?

Types that are `Copy` should have a trivial implementation of `Clone`. More formally: if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`. Manual implementations should be careful to uphold this invariant; however, unsafe code must not rely on it to ensure memory safety.

An example is an array holding more than 32 elements of a type that is `Clone`; the standard library only implements `Clone` up until arrays of size 32. In this case, the implementation of `Clone` cannot be `derive`d, but can be implemented as:

    #[derive(Copy)]
    struct Stats {
       frequencies: [i32; 100],
    }

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

## Required Methods

### `fn clone(&self) -> Self`

Returns a copy of the value.

# Examples

    let hello = "Hello"; // &str implements Clone

    assert_eq!("Hello", hello.clone());Run

## Provided Methods

### `fn clone_from(&mut self, source: &Self)`

Performs copy-assignment from `source`.

`a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality, but can be overridden to reuse the resources of `a` to avoid unnecessary allocations.

## Implementors

- `impl Clone for ParseFloatError`
- `impl<T: Clone> Clone for Wrapping<T>`
- `impl Clone for FpCategory`
- `impl Clone for TryFromIntError`
- `impl Clone for ParseIntError`
- `impl<T> Clone for Discriminant<T>`
- `impl<T: Clone + Zeroable> Clone for NonZero<T>`
- `impl<T: ?Sized> Clone for *const T`
- `impl<T: ?Sized> Clone for *mut T`
- `impl<Ret> Clone for fn() -> Ret`
- `impl<Ret> Clone for extern fn() -> Ret`
- `impl<Ret> Clone for unsafe fn() -> Ret`
- `impl<Ret> Clone for unsafe extern fn() -> Ret`
- `impl<Ret, A> Clone for fn(_: A) -> Ret`
- `impl<Ret, A> Clone for extern fn(_: A) -> Ret`
- `impl<Ret, A> Clone for extern fn(_: A, ...) -> Ret`
- `impl<Ret, A> Clone for unsafe fn(_: A) -> Ret`
- `impl<Ret, A> Clone for unsafe extern fn(_: A) -> Ret`
- `impl<Ret, A> Clone for unsafe extern fn(_: A, ...) -> Ret`
- `impl<Ret, A, B> Clone for fn(_: A, _: B) -> Ret`
- `impl<Ret, A, B> Clone for extern fn(_: A, _: B) -> Ret`
- `impl<Ret, A, B> Clone for extern fn(_: A, _: B, ...) -> Ret`
- `impl<Ret, A, B> Clone for unsafe fn(_: A, _: B) -> Ret`
- `impl<Ret, A, B> Clone for unsafe extern fn(_: A, _: B) -> Ret`
- `impl<Ret, A, B> Clone for unsafe extern fn(_: A, _: B, ...) -> Ret`
- `impl<Ret, A, B, C> Clone for fn(_: A, _: B, _: C) -> Ret`
- `impl<Ret, A, B, C> Clone for extern fn(_: A, _: B, _: C) -> Ret`
- `impl<Ret, A, B, C> Clone for extern fn(_: A, _: B, _: C, ...) -> Ret`
- `impl<Ret, A, B, C> Clone for unsafe fn(_: A, _: B, _: C) -> Ret`
- `impl<Ret, A, B, C> Clone for unsafe extern fn(_: A, _: B, _: C) -> Ret`
- `impl<Ret, A, B, C> Clone for unsafe extern fn(_: A, _: B, _: C, ...) -> Ret`
- `impl<Ret, A, B, C, D> Clone for fn(_: A, _: B, _: C, _: D) -> Ret`
- `impl<Ret, A, B, C, D> Clone for extern fn(_: A, _: B, _: C, _: D) -> Ret`
- `impl<Ret, A, B, C, D> Clone for extern fn(_: A, _: B, _: C, _: D, ...) -> Ret`
- `impl<Ret, A, B, C, D> Clone for unsafe fn(_: A, _: B, _: C, _: D) -> Ret`
- `impl<Ret, A, B, C, D> Clone for unsafe extern fn(_: A, _: B, _: C, _: D) -> Ret`
- `impl<Ret, A, B, C, D> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, ...) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for extern fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
- `impl<Ret, A, B, C, D, E> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
- `impl<Ret, A, B, C, D, E, F> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`
- `impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Clone for unsafe extern fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret`
- `impl<T: ?Sized> Clone for Shared<T>`
- `impl<T: ?Sized> Clone for PhantomData<T>`
- `impl Clone for RangeFull`
- `impl<Idx: Clone> Clone for Range<Idx>`
- `impl<Idx: Clone> Clone for RangeFrom<Idx>`
- `impl<Idx: Clone> Clone for RangeTo<Idx>`
- `impl<Idx: Clone> Clone for RangeInclusive<Idx>`
- `impl<Idx: Clone> Clone for RangeToInclusive<Idx>`
- `impl Clone for core::cmp::Ordering`
- `impl<'a, T: ?Sized> Clone for &'a T`
- `impl Clone for isize`
- `impl Clone for i8`
- `impl Clone for i16`
- `impl Clone for i32`
- `impl Clone for i64`
- `impl Clone for i128`
- `impl Clone for usize`
- `impl Clone for u8`
- `impl Clone for u16`
- `impl Clone for u32`
- `impl Clone for u64`
- `impl Clone for u128`
- `impl Clone for f32`
- `impl Clone for f64`
- `impl Clone for ()`
- `impl Clone for bool`
- `impl Clone for char`
- `impl Clone for TypeId`
- `impl<T: Copy> Clone for [T; 0]`
- `impl<T: Copy> Clone for [T; 1]`
- `impl<T: Copy> Clone for [T; 2]`
- `impl<T: Copy> Clone for [T; 3]`
- `impl<T: Copy> Clone for [T; 4]`
- `impl<T: Copy> Clone for [T; 5]`
- `impl<T: Copy> Clone for [T; 6]`
- `impl<T: Copy> Clone for [T; 7]`
- `impl<T: Copy> Clone for [T; 8]`
- `impl<T: Copy> Clone for [T; 9]`
- `impl<T: Copy> Clone for [T; 10]`
- `impl<T: Copy> Clone for [T; 11]`
- `impl<T: Copy> Clone for [T; 12]`
- `impl<T: Copy> Clone for [T; 13]`
- `impl<T: Copy> Clone for [T; 14]`
- `impl<T: Copy> Clone for [T; 15]`
- `impl<T: Copy> Clone for [T; 16]`
- `impl<T: Copy> Clone for [T; 17]`
- `impl<T: Copy> Clone for [T; 18]`
- `impl<T: Copy> Clone for [T; 19]`
- `impl<T: Copy> Clone for [T; 20]`
- `impl<T: Copy> Clone for [T; 21]`
- `impl<T: Copy> Clone for [T; 22]`
- `impl<T: Copy> Clone for [T; 23]`
- `impl<T: Copy> Clone for [T; 24]`
- `impl<T: Copy> Clone for [T; 25]`
- `impl<T: Copy> Clone for [T; 26]`
- `impl<T: Copy> Clone for [T; 27]`
- `impl<T: Copy> Clone for [T; 28]`
- `impl<T: Copy> Clone for [T; 29]`
- `impl<T: Copy> Clone for [T; 30]`
- `impl<T: Copy> Clone for [T; 31]`
- `impl<T: Copy> Clone for [T; 32]`
- `impl Clone for core::sync::atomic::Ordering`
- `impl<T: Copy> Clone for Cell<T>`
- `impl Clone for BorrowState`
- `impl<T: Clone> Clone for RefCell<T>`
- `impl Clone for CharTryFromError`
- `impl Clone for EscapeUnicode`
- `impl Clone for EscapeDefault`
- `impl Clone for EscapeDebug`
- `impl<I: Clone + Iterator<Item=u8>> Clone for DecodeUtf8<I>`
- `impl<A: Clone, R: Clone> Clone for StepBy<A, R>`
- `impl<A: Clone> Clone for Repeat<A>`
- `impl<T> Clone for Empty<T>`
- `impl<T: Clone> Clone for Once<T>`
- `impl<T: Clone> Clone for Rev<T>`
- `impl<I: Clone> Clone for Cloned<I>`
- `impl<I: Clone> Clone for Cycle<I>`
- `impl<A: Clone, B: Clone> Clone for Chain<A, B>`
- `impl<A: Clone, B: Clone> Clone for Zip<A, B>`
- `impl<I: Clone, F: Clone> Clone for Map<I, F>`
- `impl<I: Clone, P: Clone> Clone for Filter<I, P>`
- `impl<I: Clone, F: Clone> Clone for FilterMap<I, F>`
- `impl<I: Clone> Clone for Enumerate<I>`
- `impl<I: Clone + Iterator> Clone for Peekable<I> where I::Item: Clone`
- `impl<I: Clone, P: Clone> Clone for SkipWhile<I, P>`
- `impl<I: Clone, P: Clone> Clone for TakeWhile<I, P>`
- `impl<I: Clone> Clone for Skip<I>`
- `impl<I: Clone> Clone for Take<I>`
- `impl<I: Clone, St: Clone, F: Clone> Clone for Scan<I, St, F>`
- `impl<I: Clone, U: Clone + IntoIterator, F: Clone> Clone for FlatMap<I, U, F> where U::IntoIter: Clone,
  U::IntoIter: Clone`
- `impl<I: Clone> Clone for Fuse<I>`
- `impl<I: Clone, F: Clone> Clone for Inspect<I, F>`
- `impl<T: Clone> Clone for Option<T>`
- `impl<'a, A> Clone for core::option::Iter<'a, A>`
- `impl<A: Clone> Clone for IntoIter<A>`
- `impl Clone for TraitObject`
- `impl<T: Clone, E: Clone> Clone for Result<T, E>`
- `impl<'a, T> Clone for core::result::Iter<'a, T>`
- `impl<'a, T> Clone for core::slice::Iter<'a, T>`
- `impl<'a, T, P> Clone for core::slice::Split<'a, T, P> where P: Clone + FnMut(&T) -> bool`
- `impl<'a, T> Clone for Windows<'a, T>`
- `impl<'a, T> Clone for Chunks<'a, T>`
- `impl Clone for SearchStep`
- `impl<'a> Clone for CharSearcher<'a>`
- `impl<'a, 'b> Clone for CharSliceSearcher<'a, 'b>`
- `impl<'a, F: Clone> Clone for CharPredicateSearcher<'a, F> where F: FnMut(char) -> bool`
- `impl<'a, 'b> Clone for StrSearcher<'a, 'b>`
- `impl Clone for ParseBoolError`
- `impl Clone for Utf8Error`
- `impl<'a> Clone for Chars<'a>`
- `impl<'a> Clone for CharIndices<'a>`
- `impl<'a> Clone for Bytes<'a>`
- `impl<'a, P: Pattern<'a>> Clone for core::str::Split<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for RSplit<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for SplitTerminator<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for RSplitTerminator<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for SplitN<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for RSplitN<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for MatchIndices<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for RMatchIndices<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for Matches<'a, P> where P::Searcher: Clone`
- `impl<'a, P: Pattern<'a>> Clone for RMatches<'a, P> where P::Searcher: Clone`
- `impl<'a> Clone for Lines<'a>`
- `impl<'a> Clone for LinesAny<'a>`
- `impl Clone for SipHasher13`
- `impl Clone for SipHasher24`
- `impl Clone for SipHasher`
- `impl<H> Clone for BuildHasherDefault<H>`
- `impl Clone for Error`
- `impl<'a> Clone for Arguments<'a>`
- `impl<A: Clone> Clone for (A,)`
- `impl<A: Clone, B: Clone> Clone for (A, B)`
- `impl<A: Clone, B: Clone, C: Clone> Clone for (A, B, C)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone> Clone for (A, B, C, D)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone> Clone for (A, B, C, D, E)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone> Clone for (A, B, C, D, E, F)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone> Clone for (A, B, C, D, E, F, G)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone> Clone for (A, B, C, D, E, F, G, H)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone> Clone for (A, B, C, D, E, F, G, H, I)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone> Clone for (A, B, C, D, E, F, G, H, I, J)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone> Clone for (A, B, C, D, E, F, G, H, I, J, K)`
- `impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone> Clone for (A, B, C, D, E, F, G, H, I, J, K, L)`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand 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`)