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

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

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

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

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

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

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

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

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

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

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

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

### Notable traits for SplitInclusive<'a, T, P>

`impl<'a, T, P> Iterator for SplitInclusive<'a, T, P> where
P: FnMut(&T) -> bool, type Item = &'a [T];`
`[src]

### `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>ⓘ

### Notable traits for SplitInclusive<'a, P>

`impl<'a, P> Iterator for SplitInclusive<'a, P> where
P: Pattern<'a>, type Item = &'a str;`
`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Notable traits for Union<'a, T, S>

`impl<'a, T, S> Iterator for Union<'a, T, S> where
S: BuildHasher,
T: Eq + Hash, type Item = &'a T;`
`

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

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

### Notable traits for SymmetricDifference<'a, T, S>

`impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S> where
S: BuildHasher,
T: Eq + Hash, type Item = &'a T;`
`

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

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

### Notable traits for Difference<'a, T, S>

`impl<'a, T, S> Iterator for Difference<'a, T, S> where
S: BuildHasher,
T: Eq + Hash, type Item = &'a T;`
`

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

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

### Notable traits for Intersection<'a, T, S>

`impl<'a, T, S> Iterator for Intersection<'a, T, S> where
S: BuildHasher,
T: Eq + Hash, type Item = &'a T;`
`

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

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

### Notable traits for Keys<'a, K, V>

`impl<'a, K, V> Iterator for Keys<'a, K, V> type Item = &'a K;`
`

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

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

#### `fn clone_from(&mut self, source: &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>`

#### `fn clone_from(&mut self, source: &HashMap<K, V, S>)`

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

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

### Notable traits for Iter<'a, K>

`impl<'a, K> Iterator for Iter<'a, K> type Item = &'a K;`
`

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

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

### Notable traits for Iter<'a, K, V>

`impl<'a, K, V> Iterator for Iter<'a, K, V> type Item = (&'a K, &'a V);`
`

### `impl Clone for TryReserveError`

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

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

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

### Notable traits for Values<'a, K, V>

`impl<'a, K, V> Iterator for Values<'a, K, V> type Item = &'a V;`
`

### `impl Clone for TryDemangleError`

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

### `impl Clone for DwAte`

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

### `impl Clone for DwEhPe`

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

### `impl Clone for DwDefaulted`

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

### `impl<'bases, Section, R> Clone for CfiEntriesIter<'bases, Section, R> where
R: Clone + Reader,
Section: Clone + UnwindSection<R>,`

#### `fn clone(&self) -> CfiEntriesIter<'bases, Section, R>`

### `impl<R, Offset> Clone for FileEntry<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> FileEntry<R, Offset>`

### `impl<R> Clone for DebugAbbrev<R> where
R: Clone,`

#### `fn clone(&self) -> DebugAbbrev<R>`

### `impl<T> Clone for RawRngListEntry<T> where
T: Clone,`

#### `fn clone(&self) -> RawRngListEntry<T>`

### `impl<'abbrev, 'unit, R> Clone for EntriesTree<'abbrev, 'unit, R> where
R: Clone + Reader,`

#### `fn clone(&self) -> EntriesTree<'abbrev, 'unit, R>`

### `impl<R> Clone for PubTypesEntryIter<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> PubTypesEntryIter<R>`

### `impl<R, Offset> Clone for LineInstruction<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> LineInstruction<R, Offset>`

### `impl Clone for Augmentation`

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

### `impl Clone for Range`

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

### `impl<R> Clone for DebugAranges<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> DebugAranges<R>`

### `impl Clone for Format`

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

### `impl Clone for DwAccess`

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

### `impl<R> Clone for UninitializedUnwindContext<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> UninitializedUnwindContext<R>`

### `impl<'a, R> Clone for CallFrameInstructionIter<'a, R> where
R: Reader + Clone,`

#### `fn clone(&self) -> CallFrameInstructionIter<'a, R>`

### `impl<R> Clone for PubTypesEntry<R> where
R: Reader + Clone,
<R as Reader>::Offset: Clone,`

#### `fn clone(&self) -> PubTypesEntry<R>`

### `impl<T> Clone for DebugFrameOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugFrameOffset<T>`

### `impl<T> Clone for DebugLocListsBase<T> where
T: Clone,`

#### `fn clone(&self) -> DebugLocListsBase<T>`

### `impl<R, Offset> Clone for Piece<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> Piece<R, Offset>`

### `impl Clone for DwInl`

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

### `impl<R> Clone for RangeLists<R> where
R: Clone,`

#### `fn clone(&self) -> RangeLists<R>`

### `impl<R> Clone for LocationLists<R> where
R: Clone,`

#### `fn clone(&self) -> LocationLists<R>`

### `impl<R> Clone for LocationListEntry<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> LocationListEntry<R>`

### `impl<R> Clone for DebugAddr<R> where
R: Clone,`

#### `fn clone(&self) -> DebugAddr<R>`

### `impl<R> Clone for LineInstructions<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> LineInstructions<R>`

### `impl<R> Clone for LineSequence<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> LineSequence<R>`

### `impl Clone for ColumnType`

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

### `impl Clone for LittleEndian`

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

### `impl<R> Clone for DebugStr<R> where
R: Clone,`

#### `fn clone(&self) -> DebugStr<R>`

### `impl<R, Program, Offset> Clone for LineRows<R, Program, Offset> where
Offset: Clone + ReaderOffset,
Program: Clone + LineProgram<R, Offset>,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> LineRows<R, Program, Offset>`

### `impl<R> Clone for PubNamesEntry<R> where
R: Reader + Clone,
<R as Reader>::Offset: Clone,`

#### `fn clone(&self) -> PubNamesEntry<R>`

### `impl Clone for DwId`

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

### `impl<R> Clone for DebugLine<R> where
R: Clone,`

#### `fn clone(&self) -> DebugLine<R>`

### `impl<R> Clone for DebugPubTypes<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> DebugPubTypes<R>`

### `impl Clone for FileEntryFormat`

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

### `impl<R> Clone for DebugRngLists<R> where
R: Clone,`

#### `fn clone(&self) -> DebugRngLists<R>`

### `impl Clone for DwDs`

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

### `impl<T> Clone for DebugLineStrOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugLineStrOffset<T>`

### `impl<R> Clone for DebugFrame<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> DebugFrame<R>`

### `impl Clone for Abbreviations`

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

### `impl Clone for DwRle`

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

### `impl<T> Clone for DebugAddrBase<T> where
T: Clone,`

#### `fn clone(&self) -> DebugAddrBase<T>`

### `impl<R, Offset> Clone for Location<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> Location<R, Offset>`

### `impl<R> Clone for CallFrameInstruction<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> CallFrameInstruction<R>`

### `impl Clone for DwLne`

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

### `impl<R, Offset> Clone for FrameDescriptionEntry<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> FrameDescriptionEntry<R, Offset>`

### `impl<R> Clone for PubNamesEntryIter<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> PubNamesEntryIter<R>`

### `impl Clone for Value`

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

### `impl<'abbrev, 'entry, 'unit, R> Clone for AttrsIter<'abbrev, 'entry, 'unit, R> where
R: Reader + Clone,`

#### `fn clone(&self) -> AttrsIter<'abbrev, 'entry, 'unit, R>`

### `impl Clone for Encoding`

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

### `impl<T> Clone for DebugLineOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugLineOffset<T>`

### `impl Clone for DwVis`

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

### `impl Clone for DwCc`

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

### `impl Clone for DwUt`

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

### `impl<R> Clone for DebugLoc<R> where
R: Clone,`

#### `fn clone(&self) -> DebugLoc<R>`

### `impl<R> Clone for DebugLineStr<R> where
R: Clone,`

#### `fn clone(&self) -> DebugLineStr<R>`

### `impl<T> Clone for DebugLocListsIndex<T> where
T: Clone,`

#### `fn clone(&self) -> DebugLocListsIndex<T>`

### `impl Clone for Error`

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

### `impl Clone for DwOp`

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

### `impl Clone for LineRow`

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

### `impl Clone for DwVirtuality`

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

### `impl<R, Offset> Clone for Operation<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> Operation<R, Offset>`

### `impl Clone for DwForm`

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

### `impl Clone for DwAt`

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

### `impl Clone for SectionBaseAddresses`

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

### `impl<T> Clone for DebugRngListsBase<T> where
T: Clone,`

#### `fn clone(&self) -> DebugRngListsBase<T>`

### `impl<R, Offset> Clone for UnitHeader<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> UnitHeader<R, Offset>`

### `impl<T> Clone for DebugMacroOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugMacroOffset<T>`

### `impl<'abbrev, 'unit, R> Clone for EntriesRaw<'abbrev, 'unit, R> where
R: Clone + Reader,`

#### `fn clone(&self) -> EntriesRaw<'abbrev, 'unit, R>`

### `impl Clone for DwDsc`

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

### `impl<'a, R> Clone for EhHdrTable<'a, R> where
R: Reader + Clone,`

#### `fn clone(&self) -> EhHdrTable<'a, R>`

### `impl<R> Clone for CfaRule<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> CfaRule<R>`

### `impl Clone for X86_64`

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

### `impl Clone for BigEndian`

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

### `impl<T> Clone for DebugAbbrevOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugAbbrevOffset<T>`

### `impl<R> Clone for EhFrame<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> EhFrame<R>`

### `impl Clone for RunTimeEndian`

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

### `impl<T> Clone for ArangeEntry<T> where
T: Clone + Copy,`

#### `fn clone(&self) -> ArangeEntry<T>`

### `impl<T> Clone for RangeListsOffset<T> where
T: Clone,`

#### `fn clone(&self) -> RangeListsOffset<T>`

### `impl Clone for DwChildren`

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

### `impl<R> Clone for DebugRanges<R> where
R: Clone,`

#### `fn clone(&self) -> DebugRanges<R>`

### `impl Clone for DwIdx`

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

### `impl<R> Clone for DebugInfo<R> where
R: Clone,`

#### `fn clone(&self) -> DebugInfo<R>`

### `impl Clone for SectionId`

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

### `impl Clone for DwOrd`

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

### `impl<T> Clone for DebugInfoOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugInfoOffset<T>`

### `impl<R, Offset> Clone for LineProgramHeader<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> LineProgramHeader<R, Offset>`

### `impl<R, Offset> Clone for AttributeValue<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> AttributeValue<R, Offset>`

### `impl<R> Clone for DebugTypes<R> where
R: Clone,`

#### `fn clone(&self) -> DebugTypes<R>`

### `impl Clone for DwTag`

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

### `impl Clone for DwLang`

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

### `impl<T> Clone for LocationListsOffset<T> where
T: Clone,`

#### `fn clone(&self) -> LocationListsOffset<T>`

### `impl<R, Offset> Clone for TypeUnitHeader<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> TypeUnitHeader<R, Offset>`

### `impl<R> Clone for ArangeEntryIter<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> ArangeEntryIter<R>`

### `impl<R> Clone for ParsedEhFrameHdr<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> ParsedEhFrameHdr<R>`

### `impl<R> Clone for DebugStrOffsets<R> where
R: Clone,`

#### `fn clone(&self) -> DebugStrOffsets<R>`

### `impl Clone for DwLle`

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

### `impl<R> Clone for DebugLocLists<R> where
R: Clone,`

#### `fn clone(&self) -> DebugLocLists<R>`

### `impl Clone for AttributeSpecification`

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

### `impl<R> Clone for DebugPubNames<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> DebugPubNames<R>`

### `impl Clone for DwLnct`

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

### `impl<R> Clone for EhFrameHdr<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> EhFrameHdr<R>`

### `impl Clone for Abbreviation`

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

### `impl<T> Clone for DebugStrOffsetsBase<T> where
T: Clone,`

#### `fn clone(&self) -> DebugStrOffsetsBase<T>`

### `impl<T> Clone for DebugRngListsIndex<T> where
T: Clone,`

#### `fn clone(&self) -> DebugRngListsIndex<T>`

### `impl Clone for X86`

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

### `impl Clone for DebugTypeSignature`

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

### `impl<'bases, Section, R> Clone for PartialFrameDescriptionEntry<'bases, Section, R> where
R: Clone + Reader,
Section: Clone + UnwindSection<R>,
<R as Reader>::Offset: Clone,
<Section as UnwindSection<R>>::Offset: Clone,`

#### `fn clone(&self) -> PartialFrameDescriptionEntry<'bases, Section, R>`

### `impl<T> Clone for DebugStrOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugStrOffset<T>`

### `impl<T> Clone for UnitSectionOffset<T> where
T: Clone,`

#### `fn clone(&self) -> UnitSectionOffset<T>`

### `impl<R> Clone for TypeUnitHeadersIter<R> where
R: Reader + Clone,
<R as Reader>::Offset: Clone,`

#### `fn clone(&self) -> TypeUnitHeadersIter<R>`

### `impl Clone for Arm`

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

### `impl<T> Clone for DebugStrOffsetsIndex<T> where
T: Clone,`

#### `fn clone(&self) -> DebugStrOffsetsIndex<T>`

### `impl<'abbrev, 'unit, R> Clone for EntriesCursor<'abbrev, 'unit, R> where
R: Clone + Reader,`

#### `fn clone(&self) -> EntriesCursor<'abbrev, 'unit, R>`

### `impl<R, Offset> Clone for CompleteLineProgram<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> CompleteLineProgram<R, Offset>`

### `impl<'input, Endian> Clone for EndianSlice<'input, Endian> where
Endian: Clone + Endianity,`

#### `fn clone(&self) -> EndianSlice<'input, Endian>`

### `impl Clone for ValueType`

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

### `impl<'bases, Section, R> Clone for CieOrFde<'bases, Section, R> where
R: Clone + Reader,
Section: Clone + UnwindSection<R>,`

#### `fn clone(&self) -> CieOrFde<'bases, Section, R>`

### `impl<R> Clone for OperationIter<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> OperationIter<R>`

### `impl<R> Clone for Attribute<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> Attribute<R>`

### `impl Clone for Pointer`

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

### `impl<R> Clone for Expression<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> Expression<R>`

### `impl<R> Clone for RawLocListEntry<R> where
R: Reader + Clone,
<R as Reader>::Offset: Clone,`

#### `fn clone(&self) -> RawLocListEntry<R>`

### `impl Clone for DwLns`

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

### `impl<R> Clone for RegisterRule<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> RegisterRule<R>`

### `impl Clone for ReaderOffsetId`

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

### `impl<R, Offset> Clone for IncompleteLineProgram<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> IncompleteLineProgram<R, Offset>`

### `impl<'abbrev, 'unit, R, Offset> Clone for DebuggingInformationEntry<'abbrev, 'unit, R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> DebuggingInformationEntry<'abbrev, 'unit, R, Offset>`

### `impl<T> Clone for DebugMacinfoOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugMacinfoOffset<T>`

### `impl Clone for LineEncoding`

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

### `impl Clone for BaseAddresses`

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

### `impl Clone for DwMacro`

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

### `impl<T> Clone for DebugAddrIndex<T> where
T: Clone,`

#### `fn clone(&self) -> DebugAddrIndex<T>`

### `impl<R, Offset> Clone for CompilationUnitHeader<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> CompilationUnitHeader<R, Offset>`

### `impl Clone for Register`

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

### `impl Clone for DwEnd`

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

### `impl Clone for DwAddr`

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

### `impl<T> Clone for DebugTypesOffset<T> where
T: Clone,`

#### `fn clone(&self) -> DebugTypesOffset<T>`

### `impl<T> Clone for DieReference<T> where
T: Clone,`

#### `fn clone(&self) -> DieReference<T>`

### `impl<R> Clone for UnwindTableRow<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> UnwindTableRow<R>`

### `impl<R, Offset> Clone for CommonInformationEntry<R, Offset> where
Offset: Clone + ReaderOffset,
R: Clone + Reader<Offset = Offset>,`

#### `fn clone(&self) -> CommonInformationEntry<R, Offset>`

### `impl<T> Clone for EhFrameOffset<T> where
T: Clone,`

#### `fn clone(&self) -> EhFrameOffset<T>`

### `impl Clone for DwCfa`

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

### `impl<R> Clone for CompilationUnitHeadersIter<R> where
R: Reader + Clone,
<R as Reader>::Offset: Clone,`

#### `fn clone(&self) -> CompilationUnitHeadersIter<R>`

### `impl<'iter, R> Clone for RegisterRuleIter<'iter, R> where
R: Clone + Reader,`

#### `fn clone(&self) -> RegisterRuleIter<'iter, R>ⓘ

### Notable traits for RegisterRuleIter<'iter, R>

`impl<'iter, R> Iterator for RegisterRuleIter<'iter, R> where
R: Reader, type Item = &'iter (Register, RegisterRule<R>);`
`

### `impl<T> Clone for UnitOffset<T> where
T: Clone,`

#### `fn clone(&self) -> UnitOffset<T>`

### `impl<R> Clone for UnwindContext<R> where
R: Reader + Clone,`

#### `fn clone(&self) -> UnwindContext<R>`

### `impl<E> Clone for Rel32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Rel32<E>`

### `impl Clone for ImageEnclaveConfig32`

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

### `impl Clone for ImageCoffSymbolsHeader`

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

### `impl<E> Clone for IdentCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> IdentCommand<E>`

### `impl Clone for ImageRelocation`

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

### `impl Clone for AddressSize`

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

### `impl<E> Clone for RoutinesCommand_64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> RoutinesCommand_64<E>`

### `impl Clone for ImageLoadConfigDirectory32`

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

### `impl Clone for ImageLinenumber`

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

### `impl Clone for ImageArmRuntimeFunctionEntry`

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

### `impl Clone for ImageFileHeader`

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

### `impl<E> Clone for U64Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U64Bytes<E>`

### `impl<E> Clone for BuildToolVersion<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> BuildToolVersion<E>`

### `impl Clone for BinaryFormat`

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

### `impl Clone for Error`

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

### `impl<E> Clone for I16Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I16Bytes<E>`

### `impl<E> Clone for Nlist32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Nlist32<E>`

### `impl<E> Clone for Fvmlib<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Fvmlib<E>`

### `impl<E> Clone for Rela64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Rela64<E>`

### `impl<E> Clone for PreboundDylibCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> PreboundDylibCommand<E>`

### `impl<E> Clone for U32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U32<E>`

### `impl<E> Clone for TwolevelHint<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> TwolevelHint<E>`

### `impl Clone for AnonObjectHeaderV2`

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

### `impl<E> Clone for SubLibraryCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SubLibraryCommand<E>`

### `impl Clone for ImageAuxSymbolWeak`

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

### `impl<E> Clone for I64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I64<E>`

### `impl Clone for ImageAlpha64RuntimeFunctionEntry`

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

### `impl<E> Clone for EncryptionInfoCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> EncryptionInfoCommand<E>`

### `impl<E> Clone for FileHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> FileHeader32<E>`

### `impl<E> Clone for SectionHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SectionHeader64<E>`

### `impl<E> Clone for Section32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Section32<E>`

### `impl Clone for ImageDosHeader`

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

### `impl<E> Clone for U32Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U32Bytes<E>`

### `impl Clone for ImageImportByName`

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

### `impl<E> Clone for Section64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Section64<E>`

### `impl<E> Clone for I64Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I64Bytes<E>`

### `impl Clone for ImageSymbolExBytes`

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

### `impl<E> Clone for BuildVersionCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> BuildVersionCommand<E>`

### `impl Clone for ImageHotPatchHashes`

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

### `impl Clone for ImageArm64RuntimeFunctionEntry`

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

### `impl<E> Clone for NoteHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> NoteHeader64<E>`

### `impl Clone for ImageLoadConfigCodeIntegrity`

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

### `impl Clone for ImageDynamicRelocation32`

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

### `impl Clone for Ident`

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

### `impl Clone for ImageDebugMisc`

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

### `impl Clone for ImageHotPatchInfo`

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

### `impl Clone for ImageHotPatchBase`

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

### `impl<'data> Clone for SectionTable<'data>`

#### `fn clone(&self) -> SectionTable<'data>`

### `impl Clone for ImageDynamicRelocation32V2`

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

### `impl Clone for ImageEnclaveImport`

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

### `impl<E> Clone for Rel64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Rel64<E>`

### `impl<E> Clone for NoteCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> NoteCommand<E>`

### `impl Clone for ImageDataDirectory`

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

### `impl Clone for FatArch64`

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

### `impl<E> Clone for Sym32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Sym32<E>`

### `impl Clone for Guid`

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

### `impl<E> Clone for Sym64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Sym64<E>`

### `impl Clone for RelocationKind`

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

### `impl Clone for ImageOptionalHeader64`

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

### `impl Clone for ImageAuxSymbolFunctionBeginEnd`

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

### `impl Clone for BigEndian`

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

### `impl<E> Clone for DylibReference<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylibReference<E>`

### `impl Clone for ImageAuxSymbolFunction`

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

### `impl Clone for ImageTlsDirectory64`

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

### `impl<E> Clone for RpathCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> RpathCommand<E>`

### `impl<E> Clone for I16<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I16<E>`

### `impl Clone for ImageEnclaveConfig64`

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

### `impl Clone for ImageAuxSymbolTokenDef`

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

### `impl<E> Clone for Dyn32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Dyn32<E>`

### `impl Clone for ImageAlphaRuntimeFunctionEntry`

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

### `impl<E> Clone for SegmentCommand32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SegmentCommand32<E>`

### `impl Clone for ImageResourceDirStringU`

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

### `impl<E> Clone for LinkerOptionCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> LinkerOptionCommand<E>`

### `impl<E> Clone for DylinkerCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylinkerCommand<E>`

### `impl<E> Clone for U16Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U16Bytes<E>`

### `impl Clone for ImageAuxSymbolSection`

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

### `impl Clone for SectionIndex`

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

### `impl Clone for FatArch32`

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

### `impl<E> Clone for Dylib<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Dylib<E>`

### `impl<Section> Clone for SymbolFlags<Section> where
Section: Clone,`

#### `fn clone(&self) -> SymbolFlags<Section>`

### `impl<E> Clone for SymSegCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SymSegCommand<E>`

### `impl<E> Clone for DataInCodeEntry<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DataInCodeEntry<E>`

### `impl Clone for AnonObjectHeader`

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

### `impl<'data, Mach> Clone for SymbolTable<'data, Mach> where
Mach: MachHeader + Clone,
<Mach as MachHeader>::Nlist: Clone,`

#### `fn clone(&self) -> SymbolTable<'data, Mach>`

### `impl<E> Clone for DylibCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylibCommand<E>`

### `impl Clone for SymbolKind`

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

### `impl Clone for ImageNtHeaders32`

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

### `impl<E> Clone for ProgramHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> ProgramHeader64<E>`

### `impl Clone for LittleEndian`

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

### `impl<E> Clone for RoutinesCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> RoutinesCommand<E>`

### `impl Clone for ImageResourceDirectoryEntry`

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

### `impl<E> Clone for I32Bytes<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I32Bytes<E>`

### `impl<E> Clone for PrebindCksumCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> PrebindCksumCommand<E>`

### `impl<E> Clone for SourceVersionCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SourceVersionCommand<E>`

### `impl Clone for ImageResourceDirectoryString`

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

### `impl<E> Clone for DyldInfoCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DyldInfoCommand<E>`

### `impl<E> Clone for SegmentCommand64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SegmentCommand64<E>`

### `impl Clone for ImageDebugDirectory`

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

### `impl Clone for RelocationTarget`

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

### `impl<E> Clone for NoteHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> NoteHeader32<E>`

### `impl<E> Clone for CompressionHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> CompressionHeader64<E>`

### `impl Clone for CompressionFormat`

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

### `impl<E> Clone for MachHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> MachHeader64<E>`

### `impl<'data, Elf> Clone for SymbolTable<'data, Elf> where
Elf: FileHeader + Clone,
<Elf as FileHeader>::Sym: Clone,`

#### `fn clone(&self) -> SymbolTable<'data, Elf>`

### `impl<E> Clone for U16<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U16<E>`

### `impl Clone for ImageImportDescriptor`

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

### `impl<E> Clone for LinkeditDataCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> LinkeditDataCommand<E>`

### `impl<E> Clone for FvmlibCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> FvmlibCommand<E>`

### `impl Clone for ImageRomHeaders`

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

### `impl<E> Clone for EntryPointCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> EntryPointCommand<E>`

### `impl<E> Clone for Nlist64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Nlist64<E>`

### `impl Clone for ImageFunctionEntry`

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

### `impl Clone for ImageTlsDirectory32`

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

### `impl<E> Clone for CompressionHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> CompressionHeader32<E>`

### `impl Clone for ScatteredRelocationInfo`

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

### `impl Clone for ImageExportDirectory`

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

### `impl Clone for ImageSymbolBytes`

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

### `impl Clone for SectionKind`

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

### `impl Clone for FatHeader`

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

### `impl<E> Clone for DylibTableOfContents<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylibTableOfContents<E>`

### `impl Clone for NonPagedDebugInfo`

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

### `impl Clone for ImageOs2Header`

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

### `impl<'data, Elf> Clone for SectionTable<'data, Elf> where
Elf: FileHeader + Clone,
<Elf as FileHeader>::SectionHeader: Clone,`

#### `fn clone(&self) -> SectionTable<'data, Elf>`

### `impl<'data> Clone for StringTable<'data>`

#### `fn clone(&self) -> StringTable<'data>`

### `impl Clone for ImageDelayloadDescriptor`

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

### `impl Clone for ImageResourceDataEntry`

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

### `impl<E> Clone for MachHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> MachHeader32<E>`

### `impl<E> Clone for Rela32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Rela32<E>`

### `impl Clone for ImageSectionHeader`

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

### `impl Clone for ImportObjectHeader`

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

### `impl<E> Clone for Dyn64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Dyn64<E>`

### `impl<'data> Clone for Symbol<'data>`

#### `fn clone(&self) -> Symbol<'data>`

### `impl<E> Clone for Relocation<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Relocation<E>`

### `impl Clone for ImageLoadConfigDirectory64`

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

### `impl<E> Clone for ThreadCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> ThreadCommand<E>`

### `impl<E> Clone for SubClientCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SubClientCommand<E>`

### `impl Clone for ImageRomOptionalHeader`

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

### `impl<E> Clone for Syminfo64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Syminfo64<E>`

### `impl<E> Clone for DylibModule64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylibModule64<E>`

### `impl Clone for ImageFunctionEntry64`

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

### `impl Clone for ImageResourceDirectory`

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

### `impl Clone for ImageAuxSymbolCrc`

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

### `impl Clone for ImageVxdHeader`

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

### `impl Clone for ImageBaseRelocation`

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

### `impl Clone for ImageBoundForwarderRef`

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

### `impl Clone for ImageSymbolEx`

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

### `impl Clone for ImageSymbol`

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

### `impl Clone for RelocationInfo`

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

### `impl<E> Clone for TwolevelHintsCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> TwolevelHintsCommand<E>`

### `impl<E> Clone for SubFrameworkCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SubFrameworkCommand<E>`

### `impl<E> Clone for LcStr<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> LcStr<E>`

### `impl Clone for ImageArchiveMemberHeader`

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

### `impl<E> Clone for DylibModule32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DylibModule32<E>`

### `impl Clone for ImageSeparateDebugHeader`

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

### `impl<E> Clone for LoadCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> LoadCommand<E>`

### `impl Clone for SymbolSection`

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

### `impl<E> Clone for VersionMinCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> VersionMinCommand<E>`

### `impl<E> Clone for U64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> U64<E>`

### `impl<'data> Clone for CompressedData<'data>`

#### `fn clone(&self) -> CompressedData<'data>`

### `impl Clone for SectionFlags`

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

### `impl<'data> Clone for Bytes<'data>`

#### `fn clone(&self) -> Bytes<'data>`

### `impl<E> Clone for FileHeader64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> FileHeader64<E>`

### `impl Clone for FileFlags`

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

### `impl Clone for AnonObjectHeaderBigobj`

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

### `impl Clone for Architecture`

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

### `impl Clone for ImageDynamicRelocation64V2`

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

### `impl Clone for RelocationEncoding`

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

### `impl Clone for ImageNtHeaders64`

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

### `impl<E> Clone for SymtabCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SymtabCommand<E>`

### `impl Clone for ImageOptionalHeader32`

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

### `impl Clone for ImageBoundImportDescriptor`

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

### `impl Clone for ImageArchitectureEntry`

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

### `impl Clone for ImageRuntimeFunctionEntry`

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

### `impl<E> Clone for I32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> I32<E>`

### `impl<E> Clone for FvmfileCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> FvmfileCommand<E>`

### `impl<E> Clone for Syminfo32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> Syminfo32<E>`

### `impl Clone for ImageDynamicRelocation64`

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

### `impl<E> Clone for ProgramHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> ProgramHeader32<E>`

### `impl Clone for ImageDynamicRelocationTable`

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

### `impl Clone for Endianness`

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

### `impl<E> Clone for SubUmbrellaCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SubUmbrellaCommand<E>`

### `impl Clone for ImageEpilogueDynamicRelocationHeader`

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

### `impl<E> Clone for UuidCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> UuidCommand<E>`

### `impl<E> Clone for DysymtabCommand<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> DysymtabCommand<E>`

### `impl<E> Clone for EncryptionInfoCommand64<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> EncryptionInfoCommand64<E>`

### `impl Clone for SymbolIndex`

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

### `impl Clone for ImagePrologueDynamicRelocationHeader`

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

### `impl Clone for SymbolScope`

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

### `impl Clone for ImageCor20Header`

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

### `impl<E> Clone for SectionHeader32<E> where
E: Endian + Clone,`

#### `fn clone(&self) -> SectionHeader32<E>`

### `impl Clone for DataFormat`

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

### `impl Clone for MZStatus`

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

### `impl Clone for MZError`

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

### `impl Clone for CompressionLevel`

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

### `impl Clone for TDEFLStatus`

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

### `impl Clone for StreamResult`

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

### `impl Clone for TDEFLFlush`

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

### `impl Clone for MZFlush`

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

### `impl Clone for TINFLStatus`

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

### `impl Clone for CompressionStrategy`

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

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

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

Loading content...

## Implementors

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

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

### `impl Clone for std::collections::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 i8`[src]

#### `fn clone(&self) -> i8`[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 i128`[src]

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

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

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

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

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

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

#### `fn clone(&self) -> u8`[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 u128`[src]

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

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

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

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

#### `fn clone(&self) -> AllocErr`[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ⓘ

### Notable traits for EscapeDefault

`impl Iterator for EscapeDefault type Item = u8;`
`[src]

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

#### `fn clone(&self) -> Box<str>ⓘ

### Notable traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[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ⓘ

### Notable traits for EscapeDebug

`impl Iterator for EscapeDebug type Item = char;`
`[src]

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

#### `fn clone(&self) -> EscapeDefaultⓘ

### Notable traits for EscapeDefault

`impl Iterator for EscapeDefault type Item = char;`
`[src]

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

#### `fn clone(&self) -> EscapeUnicodeⓘ

### Notable traits for EscapeUnicode

`impl Iterator for EscapeUnicode type Item = char;`
`[src]

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

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

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

#### `fn clone(&self) -> ToLowercaseⓘ

### Notable traits for ToLowercase

`impl Iterator for ToLowercase type Item = char;`
`[src]

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

#### `fn clone(&self) -> ToUppercaseⓘ

### Notable traits for ToUppercase

`impl Iterator for ToUppercase type Item = char;`
`[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 FromVecWithNulError`[src]

#### `fn clone(&self) -> FromVecWithNulError`[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 std::fmt::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 NonZeroI8`[src]

#### `fn clone(&self) -> NonZeroI8`[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 NonZeroI128`[src]

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

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

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

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

#### `fn clone(&self) -> NonZeroU8`[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 NonZeroU128`[src]

#### `fn clone(&self) -> NonZeroU128`[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>ⓘ

### Notable traits for Iter<'a, A>

`impl<'a, A> Iterator for Iter<'a, A> type Item = &'a 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, V> Clone for std::collections::btree_map::Iter<'_, K, V>`[src]

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

### Notable traits for Iter<'a, K, V>

`impl<'a, K, V> Iterator for Iter<'a, K, V> where
K: 'a,
V: 'a, type Item = (&'a K, &'a V);`
`[src]

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

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

### Notable traits for Keys<'a, K, V>

`impl<'a, K, V> Iterator for Keys<'a, K, V> type Item = &'a K;`
`[src]

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

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

### Notable traits for Range<'a, K, V>

`impl<'a, K, V> Iterator for Range<'a, K, V> type Item = (&'a K, &'a V);`
`[src]

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

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

### Notable traits for Values<'a, K, V>

`impl<'a, K, V> Iterator for Values<'a, K, V> type Item = &'a V;`
`[src]

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

Shared references can be cloned, but mutable references cannot!

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

Shared references can be cloned, but mutable references cannot!

#### `fn clone(&self) -> &'_ Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized, '_> Read for &'_ mut Rimpl<W: Write + ?Sized, '_> Write for &'_ mut W`
`[src]

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for Difference<'a, T>

`impl<'a, T> Iterator for Difference<'a, T> where
T: Ord, type Item = &'a T;`
`[src]

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

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

### Notable traits for Intersection<'a, T>

`impl<'a, T> Iterator for Intersection<'a, T> where
T: Ord, type Item = &'a T;`
`[src]

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for Range<'a, T>

`impl<'a, T> Iterator for Range<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for SymmetricDifference<'a, T>

`impl<'a, T> Iterator for SymmetricDifference<'a, T> where
T: Ord, type Item = &'a T;`
`[src]

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

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

### Notable traits for Union<'a, T>

`impl<'a, T> Iterator for Union<'a, T> where
T: Ord, type Item = &'a T;`
`[src]

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

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

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for Chunks<'a, T>

`impl<'a, T> Iterator for Chunks<'a, T> type Item = &'a [T];`
`[src]

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

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

### Notable traits for ChunksExact<'a, T>

`impl<'a, T> Iterator for ChunksExact<'a, T> type Item = &'a [T];`
`[src]

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

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

### Notable traits for Iter<'a, T>

`impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;`
`[src]

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

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

### Notable traits for RChunks<'a, T>

`impl<'a, T> Iterator for RChunks<'a, T> type Item = &'a [T];`
`[src]

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

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

### Notable traits for Windows<'a, T>

`impl<'a, T> Iterator for Windows<'a, T> type Item = &'a [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>ⓘ

### Notable traits for Split<'a, T, P>

`impl<'a, T, P> Iterator for Split<'a, T, P> where
P: FnMut(&T) -> bool, type Item = &'a [T];`
`[src]

### `impl<'_, T, const N: usize> Clone for ArrayChunks<'_, T, N>`[src]

#### `fn clone(&self) -> ArrayChunks<'_, T, N>ⓘ

### Notable traits for ArrayChunks<'a, T, N>

`impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N> type Item = &'a [T; N];`
`[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>ⓘ

### Notable traits for Chain<'a>

`impl<'a> Iterator for Chain<'a> type Item = &'a (dyn Error + 'static);`
`[src]

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

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

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

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

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

#### `fn clone(&self) -> EncodeWide<'a>ⓘ

### Notable traits for EncodeWide<'a>

`impl<'a> Iterator for EncodeWide<'a> type Item = u16;`
`[src]

### `impl<'a> Clone for std::panic::Location<'a>`[src]

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

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

#### `fn clone(&self) -> Ancestors<'a>ⓘ

### Notable traits for Ancestors<'a>

`impl<'a> Iterator for Ancestors<'a> type Item = &'a Path;`
`[src]

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

#### `fn clone(&self) -> Components<'a>ⓘ

### Notable traits for Components<'a>

`impl<'a> Iterator for Components<'a> type Item = Component<'a>;`
`[src]

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

#### `fn clone(&self) -> Iter<'a>ⓘ

### Notable traits for Iter<'a>

`impl<'a> Iterator for Iter<'a> type Item = &'a OsStr;`
`[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 std::str::Bytes<'a>`[src]

#### `fn clone(&self) -> Bytes<'a>ⓘ

### Notable traits for Bytes<'_>

`impl<'_> Iterator for Bytes<'_> type Item = u8;`
`[src]

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

#### `fn clone(&self) -> CharIndices<'a>ⓘ

### Notable traits for CharIndices<'a>

`impl<'a> Iterator for CharIndices<'a> type Item = (usize, char);`
`[src]

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

#### `fn clone(&self) -> Chars<'a>ⓘ

### Notable traits for Chars<'a>

`impl<'a> Iterator for Chars<'a> type Item = char;`
`[src]

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

#### `fn clone(&self) -> EncodeUtf16<'a>ⓘ

### Notable traits for EncodeUtf16<'a>

`impl<'a> Iterator for EncodeUtf16<'a> type Item = u16;`
`[src]

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

#### `fn clone(&self) -> EscapeDebug<'a>ⓘ

### Notable traits for EscapeDebug<'a>

`impl<'a> Iterator for EscapeDebug<'a> type Item = char;`
`[src]

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

#### `fn clone(&self) -> EscapeDefault<'a>ⓘ

### Notable traits for EscapeDefault<'a>

`impl<'a> Iterator for EscapeDefault<'a> type Item = char;`
`[src]

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

#### `fn clone(&self) -> EscapeUnicode<'a>ⓘ

### Notable traits for EscapeUnicode<'a>

`impl<'a> Iterator for EscapeUnicode<'a> type Item = char;`
`[src]

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

#### `fn clone(&self) -> Lines<'a>ⓘ

### Notable traits for Lines<'a>

`impl<'a> Iterator for Lines<'a> type Item = &'a str;`
`[src]

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

#### `fn clone(&self) -> LinesAny<'a>ⓘ

### Notable traits for LinesAny<'a>

`impl<'a> Iterator for LinesAny<'a> type Item = &'a str;`
`[src]

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

#### `fn clone(&self) -> SplitAsciiWhitespace<'a>ⓘ

### Notable traits for SplitAsciiWhitespace<'a>

`impl<'a> Iterator for SplitAsciiWhitespace<'a> type Item = &'a str;`
`[src]

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

#### `fn clone(&self) -> SplitWhitespace<'a>ⓘ

### Notable traits for SplitWhitespace<'a>

`impl<'a> Iterator for SplitWhitespace<'a> type Item = &'a str;`
`[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>ⓘ

### Notable traits for MatchIndices<'a, P>

`impl<'a, P> Iterator for MatchIndices<'a, P> where
P: Pattern<'a>, type Item = (usize, &'a str);`
`[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>ⓘ

### Notable traits for Matches<'a, P>

`impl<'a, P> Iterator for Matches<'a, P> where
P: Pattern<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for RMatchIndices<'a, P>

`impl<'a, P> Iterator for RMatchIndices<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = (usize, &'a str);`
`[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>ⓘ

### Notable traits for RMatches<'a, P>

`impl<'a, P> Iterator for RMatches<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for RSplit<'a, P>

`impl<'a, P> Iterator for RSplit<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for RSplitN<'a, P>

`impl<'a, P> Iterator for RSplitN<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for RSplitTerminator<'a, P>

`impl<'a, P> Iterator for RSplitTerminator<'a, P> where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for Split<'a, P>

`impl<'a, P> Iterator for Split<'a, P> where
P: Pattern<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for SplitN<'a, P>

`impl<'a, P> Iterator for SplitN<'a, P> where
P: Pattern<'a>, type Item = &'a str;`
`[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>ⓘ

### Notable traits for SplitTerminator<'a, P>

`impl<'a, P> Iterator for SplitTerminator<'a, P> where
P: Pattern<'a>, type Item = &'a str;`
`[src]

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

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

### Notable traits for RChunksExact<'a, T>

`impl<'a, T> Iterator for RChunksExact<'a, T> type Item = &'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>ⓘ

### Notable traits for RSplit<'a, T, P>

`impl<'a, T, P> Iterator for RSplit<'a, T, P> where
P: FnMut(&T) -> bool, type Item = &'a [T];`
`[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>ⓘ

### Notable traits for Repeat<A>

`impl<A> Iterator for Repeat<A> where
A: Clone, type Item = A;`
`[src]

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

#### `fn clone(&self) -> IntoIter<A>ⓘ

### Notable traits for IntoIter<A>

`impl<A> Iterator for IntoIter<A> type Item = A;`
`[src]

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

#### `fn clone(&self) -> Chain<A, B>ⓘ

### Notable traits for Chain<A, B>

`impl<A, B> Iterator for Chain<A, B> where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Zip<A, B>ⓘ

### Notable traits for Zip<A, B>

`impl<A, B> Iterator for Zip<A, B> where
A: Iterator,
B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);`
`[src]

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

#### `fn clone(&self) -> FromFn<F>ⓘ

### Notable traits for FromFn<F>

`impl<T, F> Iterator for FromFn<F> where
F: FnMut() -> Option<T>, type Item = T;`
`[src]

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

#### `fn clone(&self) -> OnceWith<F>ⓘ

### Notable traits for OnceWith<F>

`impl<A, F> Iterator for OnceWith<F> where
F: FnOnce() -> A, type Item = A;`
`[src]

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

#### `fn clone(&self) -> RepeatWith<F>ⓘ

### Notable traits for RepeatWith<F>

`impl<A, F> Iterator for RepeatWith<F> where
F: FnMut() -> A, type Item = A;`
`[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>ⓘ

### Notable traits for DecodeUtf16<I>

`impl<I> Iterator for DecodeUtf16<I> where
I: Iterator<Item = u16>, type Item = Result<char, DecodeUtf16Error>;`
`[src]

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

#### `fn clone(&self) -> Cloned<I>ⓘ

### Notable traits for Cloned<I>

`impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone, type Item = T;`
`[src]

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

#### `fn clone(&self) -> Copied<I>ⓘ

### Notable traits for Copied<I>

`impl<'a, I, T> Iterator for Copied<I> where
I: Iterator<Item = &'a T>,
T: 'a + Copy, type Item = T;`
`[src]

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

#### `fn clone(&self) -> Cycle<I>ⓘ

### Notable traits for Cycle<I>

`impl<I> Iterator for Cycle<I> where
I: Clone + Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Enumerate<I>ⓘ

### Notable traits for Enumerate<I>

`impl<I> Iterator for Enumerate<I> where
I: Iterator, type Item = (usize, <I as Iterator>::Item);`
`[src]

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

#### `fn clone(&self) -> Fuse<I>ⓘ

### Notable traits for Fuse<I>

`impl<I> Iterator for Fuse<I> where
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Peekable<I>ⓘ

### Notable traits for Peekable<I>

`impl<I> Iterator for Peekable<I> where
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Skip<I>ⓘ

### Notable traits for Skip<I>

`impl<I> Iterator for Skip<I> where
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> StepBy<I>ⓘ

### Notable traits for StepBy<I>

`impl<I> Iterator for StepBy<I> where
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Take<I>ⓘ

### Notable traits for Take<I>

`impl<I> Iterator for Take<I> where
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> FilterMap<I, F>ⓘ

### Notable traits for FilterMap<I, F>

`impl<B, I, F> Iterator for FilterMap<I, F> where
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: Iterator, type Item = B;`
`[src]

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

#### `fn clone(&self) -> Inspect<I, F>ⓘ

### Notable traits for Inspect<I, F>

`impl<I, F> Iterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: Iterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Map<I, F>ⓘ

### Notable traits for Map<I, F>

`impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator, type Item = B;`
`[src]

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

#### `fn clone(&self) -> Filter<I, P>ⓘ

### Notable traits for Filter<I, P>

`impl<I, P> Iterator for Filter<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> MapWhile<I, P>ⓘ

### Notable traits for MapWhile<I, P>

`impl<B, I, P> Iterator for MapWhile<I, P> where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;`
`[src]

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

#### `fn clone(&self) -> SkipWhile<I, P>ⓘ

### Notable traits for SkipWhile<I, P>

`impl<I, P> Iterator for SkipWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> TakeWhile<I, P>ⓘ

### Notable traits for TakeWhile<I, P>

`impl<I, P> Iterator for TakeWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;`
`[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>ⓘ

### Notable traits for Scan<I, St, F>

`impl<B, I, St, F> Iterator for Scan<I, St, F> where
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
I: Iterator, type Item = B;`
`[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>ⓘ

### Notable traits for Flatten<I>

`impl<I, U> Iterator for Flatten<I> where
I: Iterator,
U: 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, type Item = <U as Iterator>::Item;`
`[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>ⓘ

### Notable traits for FlatMap<I, U, F>

`impl<I, U, F> Iterator for FlatMap<I, U, F> where
F: FnMut(<I as Iterator>::Item) -> U,
I: Iterator,
U: IntoIterator, type Item = <U as IntoIterator>::Item;`
`[src]

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

#### `fn clone(&self) -> Range<Idx>ⓘ

### Notable traits for Range<A>

`impl<A> Iterator for Range<A> where
A: Step, type Item = A;`
`[src]

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

#### `fn clone(&self) -> RangeFrom<Idx>ⓘ

### Notable traits for RangeFrom<A>

`impl<A> Iterator for RangeFrom<A> where
A: Step, type Item = A;`
`[src]

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

#### `fn clone(&self) -> RangeInclusive<Idx>ⓘ

### Notable traits for RangeInclusive<A>

`impl<A> Iterator for RangeInclusive<A> where
A: Step, type Item = A;`
`[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, '_> Clone for std::collections::hash_set::Iter<'_, K>`[src]

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

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

#### `fn clone(&self) -> BTreeMap<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<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>ⓘ

### Notable traits for Pin<P>

`impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;`
`[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]>ⓘ

### Notable traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[src]

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

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

#### `fn clone(&self) -> Box<T>ⓘ

### Notable traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`
`[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>ⓘ

### Notable traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`
`[src]

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

#### `fn clone(&self) -> IntoIterSorted<T>ⓘ

### Notable traits for IntoIterSorted<T>

`impl<T> Iterator for IntoIterSorted<T> where
T: Ord, type Item = T;`
`[src]

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

#### `fn clone(&self) -> IntoIter<T>ⓘ

### Notable traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = 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>ⓘ

### Notable traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`
`[src]

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

#### `fn clone(&self) -> Pending<T>ⓘ

### Notable traits for Pending<T>

`impl<T> Future for Pending<T> type Output = T;`
`[src]

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

#### `fn clone(&self) -> Ready<T>ⓘ

### Notable traits for Ready<T>

`impl<T> Future for Ready<T> type Output = T;`
`[src]

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

#### `fn clone(&self) -> Empty<T>ⓘ

### Notable traits for Empty<T>

`impl<T> Iterator for Empty<T> type Item = T;`
`[src]

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

#### `fn clone(&self) -> Once<T>ⓘ

### Notable traits for Once<T>

`impl<T> Iterator for Once<T> type Item = T;`
`[src]

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

#### `fn clone(&self) -> Rev<T>ⓘ

### Notable traits for Rev<I>

`impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator, type Item = <I as Iterator>::Item;`
`[src]

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

#### `fn clone(&self) -> OnceCell<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>ⓘ

### Notable traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = 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>ⓘ

### Notable traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`
`[src]

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

#### `fn clone(&self) -> Vec<T>ⓘ

### Notable traits for Vec<u8>

`impl Write for Vec<u8>`
`[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>ⓘ

### Notable traits for Successors<T, F>

`impl<T, F> Iterator for Successors<T, F> where
F: FnMut(&T) -> Option<T>, type Item = T;`
`[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<T, const N: usize> Clone for std::array::IntoIter<T, N> where
T: Clone,` [src]

#### `fn clone(&self) -> IntoIter<T, N>ⓘ

### Notable traits for IntoIter<T, N>

`impl<T, const N: usize> Iterator for IntoIter<T, N> type Item = T;`
`[src]

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

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

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

#### `fn clone(&self) -> Cursor<T>ⓘ

### Notable traits for Cursor<T>

`impl<T> Read for Cursor<T> where
T: AsRef<[u8]>, impl<'_> Write for Cursor<&'_ mut [u8]>impl<'_> Write for Cursor<&'_ mut Vec<u8>>impl Write for Cursor<Vec<u8>>impl Write for Cursor<Box<[u8]>>`
`[src]

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

#### `fn clone(&self) -> SyncOnceCell<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]

Loading content...