1.0.0[−][src]Trait frame_support::dispatch::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 derived 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,
}

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 derived, 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
    }
}

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());

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 Clone for NulError`[src]

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

`impl Clone for IpAddr`[src]

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

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

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

`impl Clone for TryRecvError`[src]

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

`impl<'_, K, V> Clone for Keys<'_, K, V>`[src]

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

`impl Clone for Ipv6Addr`[src]

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

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

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

`impl Clone for SocketAddr`[src]

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

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

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

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

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

`impl<K, V, S> Clone for HashMap<K, V, S> where K: Clone, S: Clone, V: Clone,` [src]

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

`impl<'a> Clone for Iter<'a>`[src]

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

`impl<'_, K, V> Clone for Iter<'_, K, V>`[src]

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

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

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

`impl Clone for Instant`[src]

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

`impl Clone for SeekFrom`[src]

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

`impl Clone for RecvError`[src]

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

`impl Clone for ThreadId`[src]

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

`impl<'a> Clone for Chain<'a>`[src]

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

`impl Clone for Permissions`[src]

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

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

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

`impl Clone for RecvTimeoutError`[src]

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

`impl Clone for ErrorKind`[src]

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

`impl<'_, T, S> Clone for Intersection<'_, T, S>`[src]

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

`impl Clone for FromBytesWithNulError`[src]

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

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

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

`impl Clone for SocketAddrV4`[src]

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

`impl Clone for ExitStatus`[src]

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

`impl Clone for stat`[src]

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

`impl Clone for PathBuf`[src]

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

`impl Clone for SocketAddrV6`[src]

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

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

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

`impl Clone for Output`[src]

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

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

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

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

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

`impl Clone for RandomState`[src]

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

`impl Clone for Metadata`[src]

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

`impl Clone for StripPrefixError`[src]

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

`impl Clone for ExitCode`[src]

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

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

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

`impl Clone for Thread`[src]

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

`impl Clone for AddrParseError`[src]

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

`impl Clone for OsString`[src]

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

`impl Clone for SystemTimeError`[src]

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

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

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

`impl Clone for WaitTimeoutResult`[src]

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

`impl<'_, T, S> Clone for Union<'_, T, S>`[src]

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

`impl<'_, T, S> Clone for Difference<'_, T, S>`[src]

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

`impl<'_, K> Clone for Iter<'_, K>`[src]

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

`impl<'_, K, V> Clone for Values<'_, K, V>`[src]

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

`impl Clone for SocketAddr`[src]

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

`impl Clone for OpenOptions`[src]

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

`impl Clone for AccessError`[src]

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

`impl Clone for VarError`[src]

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

`impl Clone for IntoStringError`[src]

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

`impl Clone for Shutdown`[src]

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

`impl Clone for FileType`[src]

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

`impl<T, S> Clone for HashSet<T, S> where S: Clone, T: Clone,` [src]

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

`impl Clone for DefaultHasher`[src]

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

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

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

`impl Clone for Ipv6MulticastScope`[src]

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

`impl<'a> Clone for IoSlice<'a>`[src]

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

`impl Clone for System`[src]

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

`impl Clone for SystemTime`[src]

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

`impl Clone for Ipv4Addr`[src]

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

`impl<'_, T, S> Clone for SymmetricDifference<'_, T, S>`[src]

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

`impl Clone for CString`[src]

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

`impl Clone for NonZeroU8`[src]

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

`impl<'_, A> Clone for Iter<'_, A>`[src]

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

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

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

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

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

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

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

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

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

`impl Clone for NonZeroU128`[src]

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

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

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

`impl<'a> Clone for EscapeDefault<'a>`[src]

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

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

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

`impl Clone for Duration`[src]

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

`impl Clone for i16`[src]

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

`impl Clone for __m128i`[src]

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

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

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

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

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

`impl Clone for IntErrorKind`[src]

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

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

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

`impl Clone for __m512d`[src]

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

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

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

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

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

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

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

`impl<'a> Clone for EscapeDebug<'a>`[src]

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

`impl Clone for TryFromSliceError`[src]

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

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

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

`impl Clone for MemoryBlock`[src]

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

`impl Clone for ParseCharError`[src]

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

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

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

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

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

`impl Clone for AllocErr`[src]

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

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

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

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

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

`impl Clone for __m256i`[src]

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

`impl Clone for i32`[src]

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

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

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

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

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

`impl Clone for u8`[src]

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

`impl Clone for Ordering`[src]

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

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

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

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

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

`impl Clone for ParseIntError`[src]

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

`impl Clone for __m64`[src]

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

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

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

`impl Clone for i64`[src]

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

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

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

`impl Clone for ReallocPlacement`[src]

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

`impl Clone for LayoutErr`[src]

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

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

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

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

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

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

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

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

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

`impl Clone for u64`[src]

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

`impl Clone for i128`[src]

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

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

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

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

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

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

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

`impl Clone for __m512`[src]

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

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

`fn clone(&self) -> Split<'_, T, P>`[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 Clone for char`[src]

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

`impl Clone for Utf8Error`[src]

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

`impl Clone for ToUppercase`[src]

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

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

Shared references can be cloned, but mutable references cannot!

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

`impl Clone for AllocInit`[src]

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

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

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

`impl Clone for CpuidResult`[src]

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

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

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

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

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

`impl Clone for i8`[src]

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

`impl Clone for TryFromIntError`[src]

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

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

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

`impl Clone for EscapeDefault`[src]

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

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

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

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

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

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

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

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

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

`impl Clone for FpCategory`[src]

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

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

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

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

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

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

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

`impl Clone for Infallible`[src]

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

`impl Clone for Layout`[src]

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

`impl Clone for NonZeroUsize`[src]

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

`impl Clone for ToLowercase`[src]

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

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

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

`impl Clone for isize`[src]

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

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

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

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

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

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

`fn clone(&self) -> MaybeUninit<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<'a> Clone for EscapeUnicode<'a>`[src]

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

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

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

`impl Clone for TraitObject`[src]

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

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

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

`impl Clone for CharTryFromError`[src]

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

`impl Clone for EscapeDebug`[src]

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

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

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

`impl Clone for NonZeroU16`[src]

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

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

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

`impl Clone for usize`[src]

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

`impl Clone for u128`[src]

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

`impl Clone for ParseFloatError`[src]

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

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

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

`impl Clone for NonZeroI64`[src]

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

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

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

`impl Clone for NoneError`[src]

`fn clone(&self) -> NoneError`[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 Clone for u32`[src]

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

`impl Clone for NonZeroI128`[src]

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

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

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

`impl Clone for NonZeroI8`[src]

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

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

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

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

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

`impl Clone for __m256`[src]

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

`impl Clone for NonZeroU64`[src]

`fn clone(&self) -> NonZeroU64`[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 Clone for __m128d`[src]

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

`impl Clone for SearchStep`[src]

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

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

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

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

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

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

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

`impl Clone for f32`[src]

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

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

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

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

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

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

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

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

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

`impl Clone for EscapeDefault`[src]

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

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

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

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

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

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

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

`impl Clone for RangeFull`[src]

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

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

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

`impl Clone for NonZeroIsize`[src]

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

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

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

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

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

`impl Clone for Waker`[src]

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

`impl Clone for TypeId`[src]

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

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

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

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

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

`impl Clone for SipHasher`[src]

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

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

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

`impl Clone for !`[src]

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

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

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

`impl Clone for __m256d`[src]

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

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

Shared references can be cloned, but mutable references cannot!

`impl Clone for __m512i`[src]

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

`impl Clone for f64`[src]

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

`impl Clone for bool`[src]

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

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

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

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

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

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

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

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

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

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

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

`impl Clone for Ordering`[src]

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

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

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

`impl Clone for NonZeroI32`[src]

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

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

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

`impl Clone for RawWakerVTable`[src]

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

`impl Clone for ParseBoolError`[src]

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

`impl Clone for u16`[src]

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

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

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

`impl Clone for NonZeroI16`[src]

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

`impl Clone for NonZeroU32`[src]

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

`impl Clone for EscapeUnicode`[src]

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

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

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

`impl Clone for DecodeUtf16Error`[src]

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

`impl Clone for __m128`[src]

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

`impl Clone for Peekable where I: Clone + Iterator, ::Item: Clone,` [src]

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

`impl<T> Clone for 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);

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

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

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

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

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

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

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

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

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

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

`impl<T> Clone for 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);

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

`fn clone(&self) -> Box<[T]>`[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<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);

`impl Clone for FromUtf8Error`[src]

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

`impl<'_, K, V> Clone for Iter<'_, K, V>`[src]

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

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

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

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

`fn clone(&self) -> Iter<'_, 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 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);

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

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

`impl<'_, K, V> Clone for Keys<'_, K, V>`[src]

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

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

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

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

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

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

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

`impl Clone for TryReserveError`[src]

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

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

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

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

`fn clone(&self) -> Box<str>`[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<'_, K, V> Clone for Values<'_, K, V>`[src]

`fn clone(&self) -> Values<'_, K, V>`[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 IntoIter<T> where T: Clone,` [src]

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

`impl<'_, K, V> Clone for Range<'_, K, V>`[src]

`fn clone(&self) -> Range<'_, K, V>`[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);

`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);