std::clone::Clone - Rust
Description: API documentation for the Rust `Clone` trait in crate `std`.
Keywords: rust, rustlang, rust-lang, Clone

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

    #[lang = "clone"]
    pub trait Clone {
    #[must_use = "cloning is often expensive and is not expected to have side effects"]
        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.

For a generic struct, `#[derive]` implements `Clone` conditionally by adding bound `Clone` on generic parameters.

    // `derive` implements Clone for Reading<T> when T is Clone.
    #[derive(Clone)]
    struct Reading<T> {
        frequency: T,
    }

Run

## 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 a generic struct holding a function pointer. In this case, the implementation of `Clone` cannot be `derive`d, but can be implemented as:

    struct Generate<T>(fn() -> T);

    impl<T> Copy for Generate<T> {}

    impl<T> Clone for Generate<T> {
        fn clone(&self) -> Self {
            *self
        }
    }

Run

## Additional implementors

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

- 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 `Clone` (e.g., `[i32; 123456]`)
- Tuple types, if each component also implements `Clone` (e.g., `()`, `(i32, bool)`)
- Closure types, if they capture no value from the environment or if all such captured values implement `Clone` themselves. Note that variables captured by shared reference always implement `Clone` (even if the referent doesn't), while variables captured by mutable reference never implement `Clone`.

## Required methods

### `#[must_use = "cloning is often expensive and is not expected to have side effects"] fn clone(&self) -> Self`

Returns a copy of the value.

# Examples

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

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

Run
Loading content...

## 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.

Loading content...

## Implementations on Foreign Types

### `impl<'a, P> Clone for SplitInclusive<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> SplitInclusive<'a, P>`[src]

### `impl Clone for uint16x2_t`[src]

#### `fn clone(&self) -> uint16x2_t`[src]

### `impl<'_, T, P> Clone for SplitInclusive<'_, T, P> where
P: Clone + FnMut(&T) -> bool,` [src]

#### `fn clone(&self) -> SplitInclusive<'_, T, P>`[src]

### `impl Clone for uint8x4_t`[src]

#### `fn clone(&self) -> uint8x4_t`[src]

### `impl Clone for int8x4_t`[src]

#### `fn clone(&self) -> int8x4_t`[src]

### `impl Clone for int16x2_t`[src]

#### `fn clone(&self) -> int16x2_t`[src]

### `impl Clone for PrintFmt`[src]

#### `fn clone(&self) -> PrintFmt`[src]

### `impl Clone for Frame`[src]

#### `fn clone(&self) -> Frame`[src]

### `impl Clone for TryDemangleError`

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

### `impl<T, S> Clone for HashSet<T, S> where
S: Clone,
T: Clone,`

#### `fn clone(&self) -> HashSet<T, S>`

### `impl<K, V, S> Clone for HashMap<K, V, S> where
K: Clone,
S: Clone,
V: Clone,`

#### `fn clone(&self) -> HashMap<K, V, S>`

### `impl Clone for CollectionAllocErr`

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

### `impl<'_, K, V> Clone for Values<'_, K, V>`

#### `fn clone(&self) -> Values<'_, K, V>`

### `impl<'_, T, S> Clone for Difference<'_, T, S>`

#### `fn clone(&self) -> Difference<'_, T, S>`

### `impl<'_, T, S> Clone for Intersection<'_, T, S>`

#### `fn clone(&self) -> Intersection<'_, T, S>`

### `impl<'_, K, V> Clone for Iter<'_, K, V>`

#### `fn clone(&self) -> Iter<'_, K, V>`

### `impl<'_, K, V> Clone for Keys<'_, K, V>`

#### `fn clone(&self) -> Keys<'_, K, V>`

### `impl<'_, T, S> Clone for Union<'_, T, S>`

#### `fn clone(&self) -> Union<'_, T, S>`

### `impl<'_, T, S> Clone for SymmetricDifference<'_, T, S>`

#### `fn clone(&self) -> SymmetricDifference<'_, T, S>`

### `impl<'_, K> Clone for Iter<'_, K>`

#### `fn clone(&self) -> Iter<'_, K>`

Loading content...

## Implementors

### `impl Clone for std::cmp::Ordering`[src]

#### `fn clone(&self) -> Ordering`[src]

### `impl Clone for TryReserveError`[src]

#### `fn clone(&self) -> TryReserveError`[src]

### `impl Clone for Infallible`[src]

#### `fn clone(&self) -> Infallible`[src]

### `impl Clone for VarError`[src]

#### `fn clone(&self) -> VarError`[src]

### `impl Clone for ErrorKind`[src]

#### `fn clone(&self) -> ErrorKind`[src]

### `impl Clone for SeekFrom`[src]

#### `fn clone(&self) -> SeekFrom`[src]

### `impl Clone for IpAddr`[src]

#### `fn clone(&self) -> IpAddr`[src]

### `impl Clone for Ipv6MulticastScope`[src]

#### `fn clone(&self) -> Ipv6MulticastScope`[src]

### `impl Clone for Shutdown`[src]

#### `fn clone(&self) -> Shutdown`[src]

### `impl Clone for std::net::SocketAddr`[src]

#### `fn clone(&self) -> SocketAddr`[src]

### `impl Clone for FpCategory`[src]

#### `fn clone(&self) -> FpCategory`[src]

### `impl Clone for IntErrorKind`[src]

#### `fn clone(&self) -> IntErrorKind`[src]

### `impl Clone for SearchStep`[src]

#### `fn clone(&self) -> SearchStep`[src]

### `impl Clone for std::sync::atomic::Ordering`[src]

#### `fn clone(&self) -> Ordering`[src]

### `impl Clone for RecvTimeoutError`[src]

#### `fn clone(&self) -> RecvTimeoutError`[src]

### `impl Clone for TryRecvError`[src]

#### `fn clone(&self) -> TryRecvError`[src]

### `impl Clone for bool`[src]

#### `fn clone(&self) -> bool`[src]

### `impl Clone for char`[src]

#### `fn clone(&self) -> char`[src]

### `impl Clone for f32`[src]

#### `fn clone(&self) -> f32`[src]

### `impl Clone for f64`[src]

#### `fn clone(&self) -> f64`[src]

### `impl Clone for i128`[src]

#### `fn clone(&self) -> i128`[src]

### `impl Clone for i16`[src]

#### `fn clone(&self) -> i16`[src]

### `impl Clone for i32`[src]

#### `fn clone(&self) -> i32`[src]

### `impl Clone for i64`[src]

#### `fn clone(&self) -> i64`[src]

### `impl Clone for i8`[src]

#### `fn clone(&self) -> i8`[src]

### `impl Clone for isize`[src]

#### `fn clone(&self) -> isize`[src]

### `impl Clone for !`[src]

#### `fn clone(&self) -> !`[src]

### `impl Clone for u128`[src]

#### `fn clone(&self) -> u128`[src]

### `impl Clone for u16`[src]

#### `fn clone(&self) -> u16`[src]

### `impl Clone for u32`[src]

#### `fn clone(&self) -> u32`[src]

### `impl Clone for u64`[src]

#### `fn clone(&self) -> u64`[src]

### `impl Clone for u8`[src]

#### `fn clone(&self) -> u8`[src]

### `impl Clone for usize`[src]

#### `fn clone(&self) -> usize`[src]

### `impl Clone for AllocErr`[src]

#### `fn clone(&self) -> AllocErr`[src]

### `impl Clone for CannotReallocInPlace`[src]

#### `fn clone(&self) -> CannotReallocInPlace`[src]

### `impl Clone for Global`[src]

#### `fn clone(&self) -> Global`[src]

### `impl Clone for Layout`[src]

#### `fn clone(&self) -> Layout`[src]

### `impl Clone for LayoutErr`[src]

#### `fn clone(&self) -> LayoutErr`[src]

### `impl Clone for System`[src]

#### `fn clone(&self) -> System`[src]

### `impl Clone for TypeId`[src]

#### `fn clone(&self) -> TypeId`[src]

### `impl Clone for TryFromSliceError`[src]

#### `fn clone(&self) -> TryFromSliceError`[src]

### `impl Clone for std::ascii::EscapeDefault`[src]

#### `fn clone(&self) -> EscapeDefault`[src]

### `impl Clone for Box<str>`[src]

#### `fn clone(&self) -> Box<str>`[src]

### `impl Clone for Box<CStr>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl Clone for Box<OsStr>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl Clone for Box<Path>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl Clone for CharTryFromError`[src]

#### `fn clone(&self) -> CharTryFromError`[src]

### `impl Clone for DecodeUtf16Error`[src]

#### `fn clone(&self) -> DecodeUtf16Error`[src]

### `impl Clone for std::char::EscapeDebug`[src]

#### `fn clone(&self) -> EscapeDebug`[src]

### `impl Clone for std::char::EscapeDefault`[src]

#### `fn clone(&self) -> EscapeDefault`[src]

### `impl Clone for std::char::EscapeUnicode`[src]

#### `fn clone(&self) -> EscapeUnicode`[src]

### `impl Clone for ParseCharError`[src]

#### `fn clone(&self) -> ParseCharError`[src]

### `impl Clone for ToLowercase`[src]

#### `fn clone(&self) -> ToLowercase`[src]

### `impl Clone for ToUppercase`[src]

#### `fn clone(&self) -> ToUppercase`[src]

### `impl Clone for UnicodeVersion`[src]

#### `fn clone(&self) -> UnicodeVersion`[src]

### `impl Clone for DefaultHasher`[src]

#### `fn clone(&self) -> DefaultHasher`[src]

### `impl Clone for RandomState`[src]

#### `fn clone(&self) -> RandomState`[src]

### `impl Clone for CString`[src]

#### `fn clone(&self) -> CString`[src]

### `impl Clone for FromBytesWithNulError`[src]

#### `fn clone(&self) -> FromBytesWithNulError`[src]

### `impl Clone for IntoStringError`[src]

#### `fn clone(&self) -> IntoStringError`[src]

### `impl Clone for NulError`[src]

#### `fn clone(&self) -> NulError`[src]

### `impl Clone for OsString`[src]

#### `fn clone(&self) -> OsString`[src]

### `impl Clone for Error`[src]

#### `fn clone(&self) -> Error`[src]

### `impl Clone for FileType`[src]

#### `fn clone(&self) -> FileType`[src]

### `impl Clone for Metadata`[src]

#### `fn clone(&self) -> Metadata`[src]

### `impl Clone for OpenOptions`[src]

#### `fn clone(&self) -> OpenOptions`[src]

### `impl Clone for Permissions`[src]

#### `fn clone(&self) -> Permissions`[src]

### `impl Clone for SipHasher`[src]

#### `fn clone(&self) -> SipHasher`[src]

### `impl Clone for PhantomPinned`[src]

#### `fn clone(&self) -> PhantomPinned`[src]

### `impl Clone for AddrParseError`[src]

#### `fn clone(&self) -> AddrParseError`[src]

### `impl Clone for Ipv4Addr`[src]

#### `fn clone(&self) -> Ipv4Addr`[src]

### `impl Clone for Ipv6Addr`[src]

#### `fn clone(&self) -> Ipv6Addr`[src]

### `impl Clone for SocketAddrV4`[src]

#### `fn clone(&self) -> SocketAddrV4`[src]

### `impl Clone for SocketAddrV6`[src]

#### `fn clone(&self) -> SocketAddrV6`[src]

### `impl Clone for NonZeroI128`[src]

#### `fn clone(&self) -> NonZeroI128`[src]

### `impl Clone for NonZeroI16`[src]

#### `fn clone(&self) -> NonZeroI16`[src]

### `impl Clone for NonZeroI32`[src]

#### `fn clone(&self) -> NonZeroI32`[src]

### `impl Clone for NonZeroI64`[src]

#### `fn clone(&self) -> NonZeroI64`[src]

### `impl Clone for NonZeroI8`[src]

#### `fn clone(&self) -> NonZeroI8`[src]

### `impl Clone for NonZeroIsize`[src]

#### `fn clone(&self) -> NonZeroIsize`[src]

### `impl Clone for NonZeroU128`[src]

#### `fn clone(&self) -> NonZeroU128`[src]

### `impl Clone for NonZeroU16`[src]

#### `fn clone(&self) -> NonZeroU16`[src]

### `impl Clone for NonZeroU32`[src]

#### `fn clone(&self) -> NonZeroU32`[src]

### `impl Clone for NonZeroU64`[src]

#### `fn clone(&self) -> NonZeroU64`[src]

### `impl Clone for NonZeroU8`[src]

#### `fn clone(&self) -> NonZeroU8`[src]

### `impl Clone for NonZeroUsize`[src]

#### `fn clone(&self) -> NonZeroUsize`[src]

### `impl Clone for ParseFloatError`[src]

#### `fn clone(&self) -> ParseFloatError`[src]

### `impl Clone for ParseIntError`[src]

#### `fn clone(&self) -> ParseIntError`[src]

### `impl Clone for TryFromIntError`[src]

#### `fn clone(&self) -> TryFromIntError`[src]

### `impl Clone for RangeFull`[src]

#### `fn clone(&self) -> RangeFull`[src]

### `impl Clone for NoneError`[src]

#### `fn clone(&self) -> NoneError`[src]

### `impl Clone for stat`[src]

#### `fn clone(&self) -> stat`[src]

### `impl Clone for std::os::unix::net::SocketAddr`[src]

#### `fn clone(&self) -> SocketAddr`[src]

### `impl Clone for PathBuf`[src]

#### `fn clone(&self) -> PathBuf`[src]

### `impl Clone for StripPrefixError`[src]

#### `fn clone(&self) -> StripPrefixError`[src]

### `impl Clone for ExitCode`[src]

#### `fn clone(&self) -> ExitCode`[src]

### `impl Clone for ExitStatus`[src]

#### `fn clone(&self) -> ExitStatus`[src]

### `impl Clone for Output`[src]

#### `fn clone(&self) -> Output`[src]

### `impl Clone for TraitObject`[src]

#### `fn clone(&self) -> TraitObject`[src]

### `impl Clone for ParseBoolError`[src]

#### `fn clone(&self) -> ParseBoolError`[src]

### `impl Clone for Utf8Error`[src]

#### `fn clone(&self) -> Utf8Error`[src]

### `impl Clone for FromUtf8Error`[src]

#### `fn clone(&self) -> FromUtf8Error`[src]

### `impl Clone for String`[src]

#### `fn clone(&self) -> String`[src]

#### `fn clone_from(&mut self, source: &String)`[src]

### `impl Clone for RecvError`[src]

#### `fn clone(&self) -> RecvError`[src]

### `impl Clone for WaitTimeoutResult`[src]

#### `fn clone(&self) -> WaitTimeoutResult`[src]

### `impl Clone for RawWakerVTable`[src]

#### `fn clone(&self) -> RawWakerVTable`[src]

### `impl Clone for Waker`[src]

#### `fn clone(&self) -> Waker`[src]

### `impl Clone for AccessError`[src]

#### `fn clone(&self) -> AccessError`[src]

### `impl Clone for Thread`[src]

#### `fn clone(&self) -> Thread`[src]

### `impl Clone for ThreadId`[src]

#### `fn clone(&self) -> ThreadId`[src]

### `impl Clone for Duration`[src]

#### `fn clone(&self) -> Duration`[src]

### `impl Clone for Instant`[src]

#### `fn clone(&self) -> Instant`[src]

### `impl Clone for SystemTime`[src]

#### `fn clone(&self) -> SystemTime`[src]

### `impl Clone for SystemTimeError`[src]

#### `fn clone(&self) -> SystemTimeError`[src]

### `impl<'_, A> Clone for std::option::Iter<'_, A>`[src]

#### `fn clone(&self) -> Iter<'_, A>`[src]

### `impl<'_, B> Clone for Cow<'_, B> where
B: ToOwned + ?Sized,` [src]

#### `fn clone(&self) -> Cow<'_, B>`[src]

#### `fn clone_from(&mut self, source: &Cow<'_, B>)`[src]

### `impl<'_, K> Clone for std::collections::hash_set::Iter<'_, K>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, K, V> Clone for std::collections::btree_map::Iter<'_, K, V>`[src]

#### `fn clone(&self) -> Iter<'_, K, V>`[src]

### `impl<'_, K, V> Clone for std::collections::btree_map::Keys<'_, K, V>`[src]

#### `fn clone(&self) -> Keys<'_, K, V>`[src]

### `impl<'_, K, V> Clone for std::collections::btree_map::Range<'_, K, V>`[src]

#### `fn clone(&self) -> Range<'_, K, V>`[src]

### `impl<'_, K, V> Clone for std::collections::btree_map::Values<'_, K, V>`[src]

#### `fn clone(&self) -> Values<'_, K, V>`[src]

### `impl<'_, K, V> Clone for std::collections::hash_map::Iter<'_, K, V>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, K, V> Clone for std::collections::hash_map::Keys<'_, K, V>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, K, V> Clone for std::collections::hash_map::Values<'_, K, V>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, T> Clone for &'_ T where
T: ?Sized,` [src]

#### `fn clone(&self) -> &'_ T`[src]

### `impl<'_, T> Clone for std::collections::binary_heap::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::Difference<'_, T>`[src]

#### `fn clone(&self) -> Difference<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::Intersection<'_, T>`[src]

#### `fn clone(&self) -> Intersection<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::Range<'_, T>`[src]

#### `fn clone(&self) -> Range<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::SymmetricDifference<'_, T>`[src]

#### `fn clone(&self) -> SymmetricDifference<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::btree_set::Union<'_, T>`[src]

#### `fn clone(&self) -> Union<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::linked_list::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for std::collections::vec_deque::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for std::result::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for Chunks<'_, T>`[src]

#### `fn clone(&self) -> Chunks<'_, T>`[src]

### `impl<'_, T> Clone for ChunksExact<'_, T>`[src]

#### `fn clone(&self) -> ChunksExact<'_, T>`[src]

### `impl<'_, T> Clone for std::slice::Iter<'_, T>`[src]

#### `fn clone(&self) -> Iter<'_, T>`[src]

### `impl<'_, T> Clone for RChunks<'_, T>`[src]

#### `fn clone(&self) -> RChunks<'_, T>`[src]

### `impl<'_, T> Clone for Windows<'_, T>`[src]

#### `fn clone(&self) -> Windows<'_, T>`[src]

### `impl<'_, T, P> Clone for std::slice::Split<'_, T, P> where
P: Clone + FnMut(&T) -> bool,` [src]

#### `fn clone(&self) -> Split<'_, T, P>`[src]

### `impl<'_, T, S> Clone for std::collections::hash_set::Difference<'_, T, S>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, T, S> Clone for std::collections::hash_set::Intersection<'_, T, S>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, T, S> Clone for std::collections::hash_set::SymmetricDifference<'_, T, S>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'_, T, S> Clone for std::collections::hash_set::Union<'_, T, S>`[src]

#### `fn clone(&self) -> Self`[src]

### `impl<'a> Clone for Component<'a>`[src]

#### `fn clone(&self) -> Component<'a>`[src]

### `impl<'a> Clone for Prefix<'a>`[src]

#### `fn clone(&self) -> Prefix<'a>`[src]

### `impl<'a> Clone for std::error::Chain<'a>`[src]

#### `fn clone(&self) -> Chain<'a>`[src]

### `impl<'a> Clone for Arguments<'a>`[src]

#### `fn clone(&self) -> Arguments<'a>`[src]

### `impl<'a> Clone for EncodeWide<'a>`[src]

#### `fn clone(&self) -> EncodeWide<'a>`[src]

### `impl<'a> Clone for Ancestors<'a>`[src]

#### `fn clone(&self) -> Ancestors<'a>`[src]

### `impl<'a> Clone for Components<'a>`[src]

#### `fn clone(&self) -> Components<'a>`[src]

### `impl<'a> Clone for std::path::Iter<'a>`[src]

#### `fn clone(&self) -> Iter<'a>`[src]

### `impl<'a> Clone for PrefixComponent<'a>`[src]

#### `fn clone(&self) -> PrefixComponent<'a>`[src]

### `impl<'a> Clone for CharSearcher<'a>`[src]

#### `fn clone(&self) -> CharSearcher<'a>`[src]

### `impl<'a> Clone for Bytes<'a>`[src]

#### `fn clone(&self) -> Bytes<'a>`[src]

### `impl<'a> Clone for CharIndices<'a>`[src]

#### `fn clone(&self) -> CharIndices<'a>`[src]

### `impl<'a> Clone for Chars<'a>`[src]

#### `fn clone(&self) -> Chars<'a>`[src]

### `impl<'a> Clone for EncodeUtf16<'a>`[src]

#### `fn clone(&self) -> EncodeUtf16<'a>`[src]

### `impl<'a> Clone for std::str::EscapeDebug<'a>`[src]

#### `fn clone(&self) -> EscapeDebug<'a>`[src]

### `impl<'a> Clone for std::str::EscapeDefault<'a>`[src]

#### `fn clone(&self) -> EscapeDefault<'a>`[src]

### `impl<'a> Clone for std::str::EscapeUnicode<'a>`[src]

#### `fn clone(&self) -> EscapeUnicode<'a>`[src]

### `impl<'a> Clone for Lines<'a>`[src]

#### `fn clone(&self) -> Lines<'a>`[src]

### `impl<'a> Clone for LinesAny<'a>`[src]

#### `fn clone(&self) -> LinesAny<'a>`[src]

### `impl<'a> Clone for SplitAsciiWhitespace<'a>`[src]

#### `fn clone(&self) -> SplitAsciiWhitespace<'a>`[src]

### `impl<'a> Clone for SplitWhitespace<'a>`[src]

#### `fn clone(&self) -> SplitWhitespace<'a>`[src]

### `impl<'a, 'b> Clone for CharSliceSearcher<'a, 'b>`[src]

#### `fn clone(&self) -> CharSliceSearcher<'a, 'b>`[src]

### `impl<'a, 'b> Clone for StrSearcher<'a, 'b>`[src]

#### `fn clone(&self) -> StrSearcher<'a, 'b>`[src]

### `impl<'a, F> Clone for CharPredicateSearcher<'a, F> where
F: Clone + FnMut(char) -> bool,` [src]

#### `fn clone(&self) -> CharPredicateSearcher<'a, F>`[src]

### `impl<'a, P> Clone for MatchIndices<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> MatchIndices<'a, P>`[src]

### `impl<'a, P> Clone for Matches<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> Matches<'a, P>`[src]

### `impl<'a, P> Clone for RMatchIndices<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> RMatchIndices<'a, P>`[src]

### `impl<'a, P> Clone for RMatches<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> RMatches<'a, P>`[src]

### `impl<'a, P> Clone for std::str::RSplit<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> RSplit<'a, P>`[src]

### `impl<'a, P> Clone for RSplitN<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> RSplitN<'a, P>`[src]

### `impl<'a, P> Clone for RSplitTerminator<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> RSplitTerminator<'a, P>`[src]

### `impl<'a, P> Clone for std::str::Split<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> Split<'a, P>`[src]

### `impl<'a, P> Clone for SplitN<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> SplitN<'a, P>`[src]

### `impl<'a, P> Clone for SplitTerminator<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: Clone,` [src]

#### `fn clone(&self) -> SplitTerminator<'a, P>`[src]

### `impl<'a, T> Clone for RChunksExact<'a, T>`[src]

#### `fn clone(&self) -> RChunksExact<'a, T>`[src]

### `impl<'a, T, P> Clone for std::slice::RSplit<'a, T, P> where
P: Clone + FnMut(&T) -> bool,
T: 'a + Clone,` [src]

#### `fn clone(&self) -> RSplit<'a, T, P>`[src]

### `impl<'f> Clone for VaListImpl<'f>`[src]

#### `fn clone(&self) -> VaListImpl<'f>`[src]

### `impl<A> Clone for Repeat<A> where
A: Clone,` [src]

#### `fn clone(&self) -> Repeat<A>`[src]

### `impl<A> Clone for std::option::IntoIter<A> where
A: Clone,` [src]

#### `fn clone(&self) -> IntoIter<A>`[src]

### `impl<A, B> Clone for std::iter::Chain<A, B> where
A: Clone,
B: Clone,` [src]

#### `fn clone(&self) -> Chain<A, B>`[src]

### `impl<A, B> Clone for Zip<A, B> where
A: Clone,
B: Clone,` [src]

#### `fn clone(&self) -> Zip<A, B>`[src]

### `impl<F> Clone for FromFn<F> where
F: Clone,` [src]

#### `fn clone(&self) -> FromFn<F>`[src]

### `impl<F> Clone for OnceWith<F> where
F: Clone,` [src]

#### `fn clone(&self) -> OnceWith<F>`[src]

### `impl<F> Clone for RepeatWith<F> where
F: Clone,` [src]

#### `fn clone(&self) -> RepeatWith<F>`[src]

### `impl<H> Clone for BuildHasherDefault<H>`[src]

#### `fn clone(&self) -> BuildHasherDefault<H>`[src]

### `impl<I> Clone for DecodeUtf16<I> where
I: Clone + Iterator<Item = u16>,` [src]

#### `fn clone(&self) -> DecodeUtf16<I>`[src]

### `impl<I> Clone for Cloned<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Cloned<I>`[src]

### `impl<I> Clone for Copied<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Copied<I>`[src]

### `impl<I> Clone for Cycle<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Cycle<I>`[src]

### `impl<I> Clone for Enumerate<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Enumerate<I>`[src]

### `impl<I> Clone for Fuse<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Fuse<I>`[src]

### `impl<I> Clone for Peekable<I> where
I: Clone + Iterator,
<I as Iterator>::Item: Clone,` [src]

#### `fn clone(&self) -> Peekable<I>`[src]

### `impl<I> Clone for Skip<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Skip<I>`[src]

### `impl<I> Clone for StepBy<I> where
I: Clone,` [src]

#### `fn clone(&self) -> StepBy<I>`[src]

### `impl<I> Clone for Take<I> where
I: Clone,` [src]

#### `fn clone(&self) -> Take<I>`[src]

### `impl<I, F> Clone for FilterMap<I, F> where
F: Clone,
I: Clone,` [src]

#### `fn clone(&self) -> FilterMap<I, F>`[src]

### `impl<I, F> Clone for Inspect<I, F> where
F: Clone,
I: Clone,` [src]

#### `fn clone(&self) -> Inspect<I, F>`[src]

### `impl<I, F> Clone for Map<I, F> where
F: Clone,
I: Clone,` [src]

#### `fn clone(&self) -> Map<I, F>`[src]

### `impl<I, P> Clone for Filter<I, P> where
I: Clone,
P: Clone,` [src]

#### `fn clone(&self) -> Filter<I, P>`[src]

### `impl<I, P> Clone for MapWhile<I, P> where
I: Clone,
P: Clone,` [src]

#### `fn clone(&self) -> MapWhile<I, P>`[src]

### `impl<I, P> Clone for SkipWhile<I, P> where
I: Clone,
P: Clone,` [src]

#### `fn clone(&self) -> SkipWhile<I, P>`[src]

### `impl<I, P> Clone for TakeWhile<I, P> where
I: Clone,
P: Clone,` [src]

#### `fn clone(&self) -> TakeWhile<I, P>`[src]

### `impl<I, St, F> Clone for Scan<I, St, F> where
F: Clone,
I: Clone,
St: Clone,` [src]

#### `fn clone(&self) -> Scan<I, St, F>`[src]

### `impl<I, U> Clone for Flatten<I> where
I: Clone + Iterator,
U: Clone + Iterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item,` [src]

#### `fn clone(&self) -> Flatten<I>`[src]

### `impl<I, U, F> Clone for FlatMap<I, U, F> where
F: Clone,
I: Clone,
U: Clone + IntoIterator,
<U as IntoIterator>::IntoIter: Clone,` [src]

#### `fn clone(&self) -> FlatMap<I, U, F>`[src]

### `impl<Idx> Clone for std::ops::Range<Idx> where
Idx: Clone,` [src]

#### `fn clone(&self) -> Range<Idx>`[src]

### `impl<Idx> Clone for RangeFrom<Idx> where
Idx: Clone,` [src]

#### `fn clone(&self) -> RangeFrom<Idx>`[src]

### `impl<Idx> Clone for RangeInclusive<Idx> where
Idx: Clone,` [src]

#### `fn clone(&self) -> RangeInclusive<Idx>`[src]

### `impl<Idx> Clone for RangeTo<Idx> where
Idx: Clone,` [src]

#### `fn clone(&self) -> RangeTo<Idx>`[src]

### `impl<Idx> Clone for RangeToInclusive<Idx> where
Idx: Clone,` [src]

#### `fn clone(&self) -> RangeToInclusive<Idx>`[src]

### `impl<K, V> Clone for BTreeMap<K, V> where
K: Clone,
V: Clone,` [src]

#### `fn clone(&self) -> BTreeMap<K, V>`[src]

#### `fn clone_from(&mut self, other: &BTreeMap<K, V>)`[src]

### `impl<K: Clone, V: Clone, S: Clone> Clone for std::collections::HashMap<K, V, S>`[src]

#### `fn clone(&self) -> HashMap<K, V, S>`[src]

### `impl<P> Clone for Pin<P> where
P: Clone,` [src]

#### `fn clone(&self) -> Pin<P>`[src]

### `impl<T> Clone for Bound<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Bound<T>`[src]

### `impl<T> Clone for Option<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Option<T>`[src]

#### `fn clone_from(&mut self, source: &Option<T>)`[src]

### `impl<T> Clone for Poll<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Poll<T>`[src]

### `impl<T> Clone for *const T where
T: ?Sized,` [src]

#### `fn clone(&self) -> *const T`[src]

### `impl<T> Clone for *mut T where
T: ?Sized,` [src]

#### `fn clone(&self) -> *mut T`[src]

### `impl<T> Clone for Box<[T]> where
T: Clone,` [src]

#### `fn clone(&self) -> Box<[T]>`[src]

### `impl<T> Clone for Box<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Box<T>`[src]

Returns a new box with a `clone()` of this box's contents.

# Examples

    let x = Box::new(5);
    let y = x.clone();

    // The value is the same
    assert_eq!(x, y);

    // But they are unique objects
    assert_ne!(&*x as *const i32, &*y as *const i32);

Run

#### `fn clone_from(&mut self, source: &Box<T>)`[src]

Copies `source`'s contents into `self` without creating a new allocation.

# Examples

    let x = Box::new(5);
    let mut y = Box::new(10);
    let yp: *const i32 = &*y;

    y.clone_from(&x);

    // The value is the same
    assert_eq!(x, y);

    // And no allocation occurred
    assert_eq!(yp, &*y);

Run

### `impl<T> Clone for Cell<T> where
T: Copy,` [src]

#### `fn clone(&self) -> Cell<T>`[src]

### `impl<T> Clone for RefCell<T> where
T: Clone,` [src]

#### `fn clone(&self) -> RefCell<T>`[src]

# Panics

Panics if the value is currently mutably borrowed.

### `impl<T> Clone for Reverse<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Reverse<T>`[src]

### `impl<T> Clone for std::collections::binary_heap::IntoIter<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T>`[src]

### `impl<T> Clone for IntoIterSorted<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIterSorted<T>`[src]

### `impl<T> Clone for std::collections::linked_list::IntoIter<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T>`[src]

### `impl<T> Clone for BTreeSet<T> where
T: Clone,` [src]

#### `fn clone(&self) -> BTreeSet<T>`[src]

#### `fn clone_from(&mut self, other: &BTreeSet<T>)`[src]

### `impl<T> Clone for BinaryHeap<T> where
T: Clone,` [src]

#### `fn clone(&self) -> BinaryHeap<T>`[src]

#### `fn clone_from(&mut self, source: &BinaryHeap<T>)`[src]

### `impl<T> Clone for LinkedList<T> where
T: Clone,` [src]

#### `fn clone(&self) -> LinkedList<T>`[src]

#### `fn clone_from(&mut self, other: &LinkedList<T>)`[src]

### `impl<T> Clone for VecDeque<T> where
T: Clone,` [src]

#### `fn clone(&self) -> VecDeque<T>`[src]

#### `fn clone_from(&mut self, other: &VecDeque<T>)`[src]

### `impl<T> Clone for std::collections::vec_deque::IntoIter<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T>`[src]

### `impl<T> Clone for Empty<T>`[src]

#### `fn clone(&self) -> Empty<T>`[src]

### `impl<T> Clone for Once<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Once<T>`[src]

### `impl<T> Clone for Rev<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Rev<T>`[src]

### `impl<T> Clone for PhantomData<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> PhantomData<T>`[src]

### `impl<T> Clone for Discriminant<T>`[src]

#### `fn clone(&self) -> Discriminant<T>`[src]

### `impl<T> Clone for ManuallyDrop<T> where
T: Clone + ?Sized,` [src]

#### `fn clone(&self) -> ManuallyDrop<T>`[src]

### `impl<T> Clone for Wrapping<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Wrapping<T>`[src]

### `impl<T> Clone for NonNull<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> NonNull<T>`[src]

### `impl<T> Clone for Rc<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> Rc<T>`[src]

Makes a clone of the `Rc` pointer.

This creates another pointer to the same allocation, increasing the strong reference count.

# Examples

    use std::rc::Rc;

    let five = Rc::new(5);

    let _ = Rc::clone(&five);

Run

### `impl<T> Clone for std::rc::Weak<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> Weak<T>`[src]

Makes a clone of the `Weak` pointer that points to the same allocation.

# Examples

    use std::rc::{Rc, Weak};

    let weak_five = Rc::downgrade(&Rc::new(5));

    let _ = Weak::clone(&weak_five);

Run

### `impl<T> Clone for std::result::IntoIter<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T>`[src]

### `impl<T> Clone for Sender<T>`[src]

#### `fn clone(&self) -> Sender<T>`[src]

### `impl<T> Clone for SyncSender<T>`[src]

#### `fn clone(&self) -> SyncSender<T>`[src]

### `impl<T> Clone for Arc<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> Arc<T>`[src]

Makes a clone of the `Arc` pointer.

This creates another pointer to the same allocation, increasing the strong reference count.

# Examples

    use std::sync::Arc;

    let five = Arc::new(5);

    let _ = Arc::clone(&five);

Run

### `impl<T> Clone for std::sync::Weak<T> where
T: ?Sized,` [src]

#### `fn clone(&self) -> Weak<T>`[src]

Makes a clone of the `Weak` pointer that points to the same allocation.

# Examples

    use std::sync::{Arc, Weak};

    let weak_five = Arc::downgrade(&Arc::new(5));

    let _ = Weak::clone(&weak_five);

Run

### `impl<T> Clone for std::vec::IntoIter<T> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T>`[src]

### `impl<T> Clone for Vec<T> where
T: Clone,` [src]

#### `fn clone(&self) -> Vec<T>`[src]

#### `fn clone_from(&mut self, other: &Vec<T>)`[src]

### `impl<T> Clone for MaybeUninit<T> where
T: Copy,` [src]

#### `fn clone(&self) -> MaybeUninit<T>`[src]

### `impl<T, E> Clone for Result<T, E> where
E: Clone,
T: Clone,` [src]

#### `fn clone(&self) -> Result<T, E>`[src]

#### `fn clone_from(&mut self, source: &Result<T, E>)`[src]

### `impl<T, F> Clone for Successors<T, F> where
F: Clone,
T: Clone,` [src]

#### `fn clone(&self) -> Successors<T, F>`[src]

### `impl<T: Clone> Clone for TrySendError<T>`[src]

#### `fn clone(&self) -> TrySendError<T>`[src]

### `impl<T: Clone> Clone for Cursor<T>`[src]

#### `fn clone(&self) -> Cursor<T>`[src]

### `impl<T: Clone> Clone for SendError<T>`[src]

#### `fn clone(&self) -> SendError<T>`[src]

### `impl<T: Clone, S: Clone> Clone for std::collections::HashSet<T, S>`[src]

#### `fn clone(&self) -> HashSet<T, S>`[src]

### `impl<Y, R> Clone for GeneratorState<Y, R> where
R: Clone,
Y: Clone,` [src]

#### `fn clone(&self) -> GeneratorState<Y, R>`[src]

### `impl<const N: usize, T> Clone for std::array::IntoIter<T, N> where
T: Clone,
[T; N]: LengthAtMost32,` [src]

#### `fn clone(&self) -> IntoIter<T, N>`[src]

Loading content...