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

## How can I implement `Clone`?

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

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

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

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

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

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

## Implementations on Foreign Types

###

`impl Clone for TryFromSliceError`

[src]

####

`fn clone(&self) -> TryFromSliceError`

[src]

####

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

1.0.0
[src]

## Implementors

###

`impl Clone for std::cmp::Ordering`

[src]

####

`fn clone(&self) -> Ordering`

[src]

####

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

[src]

###

`impl Clone for CollectionAllocErr`

[src]

####

`fn clone(&self) -> CollectionAllocErr`

[src]

####

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

1.0.0
[src]

###

`impl Clone for VarError`

[src]

####

`fn clone(&self) -> VarError`

[src]

####

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

[src]

###

`impl Clone for ErrorKind`

[src]

####

`fn clone(&self) -> ErrorKind`

[src]

####

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

[src]

###

`impl Clone for SeekFrom`

[src]

####

`fn clone(&self) -> SeekFrom`

[src]

####

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

[src]

###

`impl Clone for IpAddr`

[src]

####

`fn clone(&self) -> IpAddr`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Ipv6MulticastScope`

[src]

####

`fn clone(&self) -> Ipv6MulticastScope`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Shutdown`

[src]

####

`fn clone(&self) -> Shutdown`

[src]

####

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

[src]

###

`impl Clone for std::net::SocketAddr`

[src]

####

`fn clone(&self) -> SocketAddr`

[src]

####

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

[src]

###

`impl Clone for FpCategory`

[src]

####

`fn clone(&self) -> FpCategory`

[src]

####

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

[src]

###

`impl Clone for SearchStep`

[src]

####

`fn clone(&self) -> SearchStep`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ParseError`

[src]

####

`fn clone(&self) -> ParseError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for std::sync::atomic::Ordering`

[src]

####

`fn clone(&self) -> Ordering`

[src]

####

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

[src]

###

`impl Clone for RecvTimeoutError`

[src]

####

`fn clone(&self) -> RecvTimeoutError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for TryRecvError`

[src]

####

`fn clone(&self) -> TryRecvError`

[src]

####

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

[src]

###

`impl Clone for bool`

[src]

####

`fn clone(&self) -> bool`

[src]

####

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

[src]

###

`impl Clone for char`

[src]

####

`fn clone(&self) -> char`

[src]

####

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

[src]

###

`impl Clone for f32`

[src]

####

`fn clone(&self) -> f32`

[src]

####

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

[src]

###

`impl Clone for f64`

[src]

####

`fn clone(&self) -> f64`

[src]

####

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

[src]

###

`impl Clone for i128`

[src]

####

`fn clone(&self) -> i128`

[src]

####

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

[src]

###

`impl Clone for i16`

[src]

####

`fn clone(&self) -> i16`

[src]

####

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

[src]

###

`impl Clone for i32`

[src]

####

`fn clone(&self) -> i32`

[src]

####

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

[src]

###

`impl Clone for i64`

[src]

####

`fn clone(&self) -> i64`

[src]

####

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

[src]

###

`impl Clone for i8`

[src]

####

`fn clone(&self) -> i8`

[src]

####

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

[src]

###

`impl Clone for isize`

[src]

####

`fn clone(&self) -> isize`

[src]

####

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

[src]

###

`impl Clone for !`

[src]

####

`fn clone(&self) -> !`

[src]

####

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

1.0.0
[src]

###

`impl Clone for u128`

[src]

####

`fn clone(&self) -> u128`

[src]

####

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

[src]

###

`impl Clone for u16`

[src]

####

`fn clone(&self) -> u16`

[src]

####

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

[src]

###

`impl Clone for u32`

[src]

####

`fn clone(&self) -> u32`

[src]

####

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

[src]

###

`impl Clone for u64`

[src]

####

`fn clone(&self) -> u64`

[src]

####

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

[src]

###

`impl Clone for u8`

[src]

####

`fn clone(&self) -> u8`

[src]

####

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

[src]

###

`impl Clone for usize`

[src]

####

`fn clone(&self) -> usize`

[src]

####

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

[src]

###

`impl Clone for AllocErr`

[src]

####

`fn clone(&self) -> AllocErr`

[src]

####

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

1.0.0
[src]

###

`impl Clone for CannotReallocInPlace`

[src]

####

`fn clone(&self) -> CannotReallocInPlace`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Global`

[src]

####

`fn clone(&self) -> Global`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Layout`

[src]

####

`fn clone(&self) -> Layout`

[src]

####

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

1.0.0
[src]

###

`impl Clone for LayoutErr`

[src]

####

`fn clone(&self) -> LayoutErr`

[src]

####

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

1.0.0
[src]

###

`impl Clone for TypeId`

[src]

####

`fn clone(&self) -> TypeId`

[src]

####

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

[src]

###

`impl Clone for Box<str>`

[src]

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

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

[src]

####

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

1.0.0
[src]

###

`impl Clone for Box<CStr>`

[src]

####

`fn clone(&self) -> Self`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Box<OsStr>`

[src]

####

`fn clone(&self) -> Self`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Box<Path>`

[src]

####

`fn clone(&self) -> Self`

[src]

####

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

1.0.0
[src]

###

`impl Clone for CharTryFromError`

[src]

####

`fn clone(&self) -> CharTryFromError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for DecodeUtf16Error`

[src]

####

`fn clone(&self) -> DecodeUtf16Error`

[src]

####

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

1.0.0
[src]

###

`impl Clone for EscapeDebug`

[src]

####
ⓘImportant traits for EscapeDebug

### Important traits for EscapeDebug

`impl Iterator for EscapeDebug type Item = char;`

`fn clone(&self) -> EscapeDebug`

[src]

####

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

1.0.0
[src]

###

`impl Clone for EscapeDefault`

[src]

####
ⓘImportant traits for EscapeDefault

### Important traits for EscapeDefault

`impl Iterator for EscapeDefault type Item = char;`

`fn clone(&self) -> EscapeDefault`

[src]

####

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

[src]

###

`impl Clone for EscapeUnicode`

[src]

####
ⓘImportant traits for EscapeUnicode

### Important traits for EscapeUnicode

`impl Iterator for EscapeUnicode type Item = char;`

`fn clone(&self) -> EscapeUnicode`

[src]

####

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

[src]

###

`impl Clone for ParseCharError`

[src]

####

`fn clone(&self) -> ParseCharError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ToLowercase`

[src]

####
ⓘImportant traits for ToLowercase

### Important traits for ToLowercase

`impl Iterator for ToLowercase type Item = char;`

`fn clone(&self) -> ToLowercase`

[src]

####

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

[src]

###

`impl Clone for ToUppercase`

[src]

####
ⓘImportant traits for ToUppercase

### Important traits for ToUppercase

`impl Iterator for ToUppercase type Item = char;`

`fn clone(&self) -> ToUppercase`

[src]

####

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

[src]

###

`impl Clone for UnicodeVersion`

[src]

####

`fn clone(&self) -> UnicodeVersion`

[src]

####

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

1.0.0
[src]

###

`impl Clone for DefaultHasher`

[src]

####

`fn clone(&self) -> DefaultHasher`

[src]

####

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

1.0.0
[src]

###

`impl Clone for RandomState`

[src]

####

`fn clone(&self) -> RandomState`

[src]

####

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

1.0.0
[src]

###

`impl Clone for CString`

[src]

####

`fn clone(&self) -> CString`

[src]

####

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

[src]

###

`impl Clone for FromBytesWithNulError`

[src]

####

`fn clone(&self) -> FromBytesWithNulError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for IntoStringError`

[src]

####

`fn clone(&self) -> IntoStringError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NulError`

[src]

####

`fn clone(&self) -> NulError`

[src]

####

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

[src]

###

`impl Clone for OsString`

[src]

####

`fn clone(&self) -> OsString`

[src]

####

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

[src]

###

`impl Clone for Error`

[src]

####

`fn clone(&self) -> Error`

[src]

####

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

[src]

###

`impl Clone for FileType`

[src]

####

`fn clone(&self) -> FileType`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Metadata`

[src]

####

`fn clone(&self) -> Metadata`

[src]

####

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

[src]

###

`impl Clone for OpenOptions`

[src]

####

`fn clone(&self) -> OpenOptions`

[src]

####

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

[src]

###

`impl Clone for Permissions`

[src]

####

`fn clone(&self) -> Permissions`

[src]

####

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

[src]

###

`impl Clone for SipHasher`

[src]

####

`fn clone(&self) -> SipHasher`

[src]

####

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

[src]

###

`impl Clone for Pinned`

[src]

####

`fn clone(&self) -> Pinned`

[src]

####

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

1.0.0
[src]

###

`impl Clone for AddrParseError`

[src]

####

`fn clone(&self) -> AddrParseError`

[src]

####

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

[src]

###

`impl Clone for Ipv4Addr`

[src]

####

`fn clone(&self) -> Ipv4Addr`

[src]

####

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

[src]

###

`impl Clone for Ipv6Addr`

[src]

####

`fn clone(&self) -> Ipv6Addr`

[src]

####

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

[src]

###

`impl Clone for SocketAddrV4`

[src]

####

`fn clone(&self) -> SocketAddrV4`

[src]

####

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

[src]

###

`impl Clone for SocketAddrV6`

[src]

####

`fn clone(&self) -> SocketAddrV6`

[src]

####

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

[src]

###

`impl Clone for NonZeroU128`

[src]

####

`fn clone(&self) -> NonZeroU128`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NonZeroU16`

[src]

####

`fn clone(&self) -> NonZeroU16`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NonZeroU32`

[src]

####

`fn clone(&self) -> NonZeroU32`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NonZeroU64`

[src]

####

`fn clone(&self) -> NonZeroU64`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NonZeroU8`

[src]

####

`fn clone(&self) -> NonZeroU8`

[src]

####

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

1.0.0
[src]

###

`impl Clone for NonZeroUsize`

[src]

####

`fn clone(&self) -> NonZeroUsize`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ParseFloatError`

[src]

####

`fn clone(&self) -> ParseFloatError`

[src]

####

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

[src]

###

`impl Clone for ParseIntError`

[src]

####

`fn clone(&self) -> ParseIntError`

[src]

####

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

[src]

###

`impl Clone for TryFromIntError`

[src]

####

`fn clone(&self) -> TryFromIntError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for RangeFull`

[src]

####

`fn clone(&self) -> RangeFull`

[src]

####

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

[src]

###

`impl Clone for NoneError`

[src]

####

`fn clone(&self) -> NoneError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for stat`

[src]

####

`fn clone(&self) -> stat`

[src]

####

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

1.0.0
[src]

###

`impl Clone for std::os::unix::net::SocketAddr`

[src]

####

`fn clone(&self) -> SocketAddr`

[src]

####

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

1.0.0
[src]

###

`impl Clone for PathBuf`

[src]

####

`fn clone(&self) -> PathBuf`

[src]

####

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

[src]

###

`impl Clone for StripPrefixError`

[src]

####

`fn clone(&self) -> StripPrefixError`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ExitCode`

[src]

####

`fn clone(&self) -> ExitCode`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ExitStatus`

[src]

####

`fn clone(&self) -> ExitStatus`

[src]

####

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

[src]

###

`impl Clone for Output`

[src]

####

`fn clone(&self) -> Output`

[src]

####

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

[src]

###

`impl Clone for TraitObject`

[src]

####

`fn clone(&self) -> TraitObject`

[src]

####

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

1.0.0
[src]

###

`impl Clone for ParseBoolError`

[src]

####

`fn clone(&self) -> ParseBoolError`

[src]

####

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

[src]

###

`impl Clone for Utf8Error`

[src]

####

`fn clone(&self) -> Utf8Error`

[src]

####

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

[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]

####

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

[src]

###

`impl Clone for WaitTimeoutResult`

[src]

####

`fn clone(&self) -> WaitTimeoutResult`

[src]

####

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

1.0.0
[src]

###

`impl Clone for LocalWaker`

[src]

####

`fn clone(&self) -> LocalWaker`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Waker`

[src]

####

`fn clone(&self) -> Waker`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Thread`

[src]

####

`fn clone(&self) -> Thread`

[src]

####

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

[src]

###

`impl Clone for ThreadId`

[src]

####

`fn clone(&self) -> ThreadId`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Duration`

[src]

####

`fn clone(&self) -> Duration`

[src]

####

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

1.0.0
[src]

###

`impl Clone for Instant`

[src]

####

`fn clone(&self) -> Instant`

[src]

####

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

1.0.0
[src]

###

`impl Clone for SystemTime`

[src]

####

`fn clone(&self) -> SystemTime`

[src]

####

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

1.0.0
[src]

###

`impl Clone for SystemTimeError`

[src]

####

`fn clone(&self) -> SystemTimeError`

[src]

####

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

1.0.0
[src]

###

`impl<'_, A> Clone for std::option::Iter<'_, A>`

[src]

####
ⓘImportant traits for Iter<'a, A>

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

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

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for &'_ mut I

### Important traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'a, R: Read + ?Sized> Read for &'a mut Rimpl<'a, W: Write + ?Sized> Write for &'a mut W`

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

[src]

####

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

[src]

###

`impl<'_, T> Clone for std::result::Iter<'_, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

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

[src]

####

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

[src]

###

`impl<'_, T> Clone for Chunks<'_, T>`

[src]

####
ⓘImportant traits for Chunks<'a, T>

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

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

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

[src]

####

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

[src]

###

`impl<'_, T> Clone for ChunksExact<'_, T>`

[src]

####
ⓘImportant traits for ChunksExact<'a, T>

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

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

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

[src]

####

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

1.0.0
[src]

###

`impl<'_, T> Clone for std::slice::Iter<'_, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

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

[src]

####

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

[src]

###

`impl<'_, T> Clone for Windows<'_, T>`

[src]

####
ⓘImportant traits for Windows<'a, T>

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

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

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Split<'a, T, P>

### Important 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];`

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

[src]

####

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

[src]

###

`impl<'a> Clone for Component<'a>`

[src]

####

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

[src]

####

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

[src]

###

`impl<'a> Clone for Prefix<'a>`

[src]

####

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

[src]

####

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

[src]

###

`impl<'a> Clone for Arguments<'a>`

[src]

####

`fn clone(&self) -> Arguments<'a>`

[src]

####

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

[src]

###

`impl<'a> Clone for EncodeWide<'a>`

[src]

####
ⓘImportant traits for EncodeWide<'a>

### Important traits for EncodeWide<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for Ancestors<'a>`

[src]

####
ⓘImportant traits for Ancestors<'a>

### Important traits for Ancestors<'a>

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

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

[src]

####

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

1.0.0
[src]

###

`impl<'a> Clone for Components<'a>`

[src]

####
ⓘImportant traits for Components<'a>

### Important traits for Components<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for std::path::Iter<'a>`

[src]

####
ⓘImportant traits for Iter<'a>

### Important traits for Iter<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for PrefixComponent<'a>`

[src]

####

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

[src]

####

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

[src]

###

`impl<'a> Clone for CharSearcher<'a>`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<'a> Clone for Bytes<'a>`

[src]

####
ⓘImportant traits for Bytes<'_>

### Important traits for Bytes<'_>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for CharIndices<'a>`

[src]

####
ⓘImportant traits for CharIndices<'a>

### Important traits for CharIndices<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for Chars<'a>`

[src]

####
ⓘImportant traits for Chars<'a>

### Important traits for Chars<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for EncodeUtf16<'a>`

[src]

####
ⓘImportant traits for EncodeUtf16<'a>

### Important traits for EncodeUtf16<'a>

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

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

[src]

####

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

1.0.0
[src]

###

`impl<'a> Clone for Lines<'a>`

[src]

####
ⓘImportant traits for Lines<'a>

### Important traits for Lines<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for LinesAny<'a>`

[src]

####
ⓘImportant traits for LinesAny<'a>

### Important traits for LinesAny<'a>

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

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

[src]

####

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

[src]

###

`impl<'a> Clone for SplitAsciiWhitespace<'a>`

[src]

####
ⓘImportant traits for SplitAsciiWhitespace<'a>

### Important traits for SplitAsciiWhitespace<'a>

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

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

[src]

####

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

1.0.0
[src]

###

`impl<'a> Clone for SplitWhitespace<'a>`

[src]

####
ⓘImportant traits for SplitWhitespace<'a>

### Important traits for SplitWhitespace<'a>

`impl<'a> Iterator for SplitWhitespace<'a> type Item = &'a str;`

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

[src]

####

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

1.0.0
[src]

###

`impl<'a, 'b> Clone for CharSliceSearcher<'a, 'b>`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<'a, 'b> Clone for StrSearcher<'a, 'b>`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<'a, B> Clone for Cow<'a, B> where B: ToOwned + ?Sized,`

[src]

####

`fn clone(&self) -> Cow<'a, B>`

[src]

####

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

####

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

1.0.0
[src]

###

`impl<'a, K> Clone for std::collections::hash_set::Iter<'a, K>`

[src]

####
ⓘImportant traits for Iter<'a, K>

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

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::btree_map::Iter<'a, K, V>`

[src]

####
ⓘImportant traits for Iter<'a, K, V>

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::btree_map::Keys<'a, K, V>`

[src]

####
ⓘImportant traits for Keys<'a, K, V>

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

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::btree_map::Range<'a, K, V>`

[src]

####
ⓘImportant traits for Range<'a, K, V>

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

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

`fn clone(&self) -> Range<'a, K, V>`

[src]

####

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

1.0.0
[src]

###

`impl<'a, K, V> Clone for std::collections::btree_map::Values<'a, K, V>`

[src]

####
ⓘImportant traits for Values<'a, K, V>

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

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::hash_map::Iter<'a, K, V>`

[src]

####
ⓘImportant traits for Iter<'a, K, V>

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

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::hash_map::Keys<'a, K, V>`

[src]

####
ⓘImportant traits for Keys<'a, K, V>

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

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

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

[src]

####

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

[src]

###

`impl<'a, K, V> Clone for std::collections::hash_map::Values<'a, K, V>`

[src]

####
ⓘImportant traits for Values<'a, K, V>

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

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

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for MatchIndices<'a, P>

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

`impl<'a, P> Iterator for MatchIndices<'a, P> where
P: Pattern<'a>, type Item = (usize, &'a str);`

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for Matches<'a, P>

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

`impl<'a, P> Iterator for Matches<'a, P> where
P: Pattern<'a>, type Item = &'a str;`

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for RMatchIndices<'a, P>

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

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for RMatches<'a, P>

### Important 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;`

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for RSplit<'a, P>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for RSplitN<'a, P>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for RSplitTerminator<'a, P>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Split<'a, P>

### Important traits for Split<'a, P>

`impl<'a, P> Iterator for Split<'a, P> where
P: Pattern<'a>, type Item = &'a str;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for SplitN<'a, P>

### Important traits for SplitN<'a, P>

`impl<'a, P> Iterator for SplitN<'a, P> where
P: Pattern<'a>, type Item = &'a str;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for SplitTerminator<'a, P>

### Important traits for SplitTerminator<'a, P>

`impl<'a, P> Iterator for SplitTerminator<'a, P> where
P: Pattern<'a>, type Item = &'a str;`

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

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::binary_heap::Iter<'a, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

`fn clone(&self) -> Iter<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::btree_set::Difference<'a, T>`

[src]

####
ⓘImportant traits for Difference<'a, T>

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

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

`fn clone(&self) -> Difference<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::btree_set::Intersection<'a, T>`

[src]

####
ⓘImportant traits for Intersection<'a, T>

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

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

`fn clone(&self) -> Intersection<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::btree_set::Iter<'a, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

`fn clone(&self) -> Iter<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::btree_set::Range<'a, T>`

[src]

####
ⓘImportant traits for Range<'a, T>

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

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

`fn clone(&self) -> Range<'a, T>`

[src]

####

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

1.0.0
[src]

###

`impl<'a, T> Clone for std::collections::btree_set::SymmetricDifference<'a, T>`

[src]

####
ⓘImportant traits for SymmetricDifference<'a, T>

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

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

`fn clone(&self) -> SymmetricDifference<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::btree_set::Union<'a, T>`

[src]

####
ⓘImportant traits for Union<'a, T>

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

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

`fn clone(&self) -> Union<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::linked_list::Iter<'a, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

`fn clone(&self) -> Iter<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for std::collections::vec_deque::Iter<'a, T>`

[src]

####
ⓘImportant traits for Iter<'a, T>

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

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

`fn clone(&self) -> Iter<'a, T>`

[src]

####

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

[src]

###

`impl<'a, T> Clone for RChunks<'a, T>`

[src]

####
ⓘImportant traits for RChunks<'a, T>

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

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

`fn clone(&self) -> RChunks<'a, T>`

[src]

####

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

1.0.0
[src]

###

`impl<'a, T> Clone for RChunksExact<'a, T>`

[src]

####
ⓘImportant traits for RChunksExact<'a, T>

### Important traits for RChunksExact<'a, T>

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

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for RSplit<'a, T, P>

### Important 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];`

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

[src]

####

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

1.0.0
[src]

###

`impl<'a, T, S> Clone for std::collections::hash_set::Difference<'a, T, S>`

[src]

####
ⓘImportant traits for Difference<'a, T, S>

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

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

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

[src]

####

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

[src]

###

`impl<'a, T, S> Clone for std::collections::hash_set::Intersection<'a, T, S>`

[src]

####
ⓘImportant traits for Intersection<'a, T, S>

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

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

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

[src]

####

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

[src]

###

`impl<'a, T, S> Clone for std::collections::hash_set::SymmetricDifference<'a, T, S>`

[src]

####
ⓘImportant traits for SymmetricDifference<'a, T, S>

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

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

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

[src]

####

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

[src]

###

`impl<'a, T, S> Clone for std::collections::hash_set::Union<'a, T, S>`

[src]

####
ⓘImportant traits for Union<'a, T, S>

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

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

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

[src]

####

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

[src]

###

`impl<A> Clone for Repeat<A> where A: Clone,`

[src]

####
ⓘImportant traits for Repeat<A>

### Important traits for Repeat<A>

`impl<A> Iterator for Repeat<A> where
A: Clone, type Item = A;`

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

[src]

####

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

[src]

###

`impl<A> Clone for std::option::IntoIter<A> where A: Clone,`

[src]

####
ⓘImportant traits for IntoIter<A>

### Important traits for IntoIter<A>

`impl<A> Iterator for IntoIter<A> type Item = A;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Chain<A, B>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Zip<A, B>

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

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

[src]

####

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

[src]

###

`impl<F> Clone for RepeatWith<F> where F: Clone,`

[src]

####
ⓘImportant traits for RepeatWith<F>

### Important traits for RepeatWith<F>

`impl<A, F> Iterator for RepeatWith<F> where
F: FnMut() -> A, type Item = A;`

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

[src]

####

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

1.0.0
[src]

###

`impl<H> Clone for BuildHasherDefault<H>`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####
ⓘImportant traits for DecodeUtf16<I>

### Important traits for DecodeUtf16<I>

`impl<I> Iterator for DecodeUtf16<I> where
I: Iterator<Item = u16>, type Item = Result<char, DecodeUtf16Error>;`

`fn clone(&self) -> DecodeUtf16<I>`

[src]

####

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

1.0.0
[src]

###

`impl<I> Clone for Cloned<I> where I: Clone,`

[src]

####
ⓘImportant traits for Cloned<I>

### Important traits for Cloned<I>

`impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone, type Item = T;`

`fn clone(&self) -> Cloned<I>`

[src]

####

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

1.0.0
[src]

###

`impl<I> Clone for Cycle<I> where I: Clone,`

[src]

####
ⓘImportant traits for Cycle<I>

### Important traits for Cycle<I>

`impl<I> Iterator for Cycle<I> where
I: Clone + Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> Cycle<I>`

[src]

####

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

[src]

###

`impl<I> Clone for Enumerate<I> where I: Clone,`

[src]

####
ⓘImportant traits for Enumerate<I>

### Important traits for Enumerate<I>

`impl<I> Iterator for Enumerate<I> where
I: Iterator, type Item = (usize, <I as Iterator>::Item);`

`fn clone(&self) -> Enumerate<I>`

[src]

####

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

[src]

###

`impl<I> Clone for Fuse<I> where I: Clone,`

[src]

####
ⓘImportant traits for Fuse<I>

### Important traits for Fuse<I>

`impl<I> Iterator for Fuse<I> where
I: FusedIterator, impl<I> Iterator for Fuse<I> where
I: Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> Fuse<I>`

[src]

####

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

[src]

###

`impl<I> Clone for Peekable<I> where I: Clone + Iterator, <I as Iterator>::Item: Clone,`

[src]

####
ⓘImportant traits for Peekable<I>

### Important traits for Peekable<I>

`impl<I> Iterator for Peekable<I> where
I: Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> Peekable<I>`

[src]

####

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

[src]

###

`impl<I> Clone for Skip<I> where I: Clone,`

[src]

####
ⓘImportant traits for Skip<I>

### Important traits for Skip<I>

`impl<I> Iterator for Skip<I> where
I: Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> Skip<I>`

[src]

####

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

[src]

###

`impl<I> Clone for StepBy<I> where I: Clone,`

[src]

####
ⓘImportant traits for StepBy<I>

### Important traits for StepBy<I>

`impl<I> Iterator for StepBy<I> where
I: Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> StepBy<I>`

[src]

####

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

1.0.0
[src]

###

`impl<I> Clone for Take<I> where I: Clone,`

[src]

####
ⓘImportant traits for Take<I>

### Important traits for Take<I>

`impl<I> Iterator for Take<I> where
I: Iterator, type Item = <I as Iterator>::Item;`

`fn clone(&self) -> Take<I>`

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for FilterMap<I, F>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Inspect<I, F>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Map<I, F>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Filter<I, P>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for SkipWhile<I, P>

### Important 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;`

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for TakeWhile<I, P>

### Important 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;`

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

[src]

####

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

[src]

###

`impl<I, St, F> Clone for Scan<I, St, F> where F: Clone, I: Clone, St: Clone,`

[src]

####
ⓘImportant traits for Scan<I, St, F>

### Important 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;`

`fn clone(&self) -> Scan<I, St, F>`

[src]

####

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

[src]

###

`impl<I, U> Clone for Flatten<I> where I: Iterator + Clone, U: Iterator + Clone, <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]

####
ⓘImportant traits for Flatten<I>

### Important 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;`

`fn clone(&self) -> Flatten<I>`

[src]

####

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

1.0.0
[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]

####
ⓘImportant traits for FlatMap<I, U, F>

### Important 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;`

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

[src]

####

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

[src]

###

`impl<Idx> Clone for std::ops::Range<Idx> where Idx: Clone,`

[src]

####
ⓘImportant traits for Range<A>

### Important traits for Range<A>

`impl<A> Iterator for Range<A> where
A: Step, type Item = A;`

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

[src]

####

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

[src]

###

`impl<Idx> Clone for RangeFrom<Idx> where Idx: Clone,`

[src]

####
ⓘImportant traits for RangeFrom<A>

### Important traits for RangeFrom<A>

`impl<A> Iterator for RangeFrom<A> where
A: Step, type Item = A;`

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

[src]

####

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

[src]

###

`impl<Idx> Clone for RangeInclusive<Idx> where Idx: Clone,`

[src]

####
ⓘImportant traits for RangeInclusive<A>

### Important traits for RangeInclusive<A>

`impl<A> Iterator for RangeInclusive<A> where
A: Step, type Item = A;`

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

[src]

####

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

1.0.0
[src]

###

`impl<Idx> Clone for RangeTo<Idx> where Idx: Clone,`

[src]

####

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

[src]

####

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

[src]

###

`impl<Idx> Clone for RangeToInclusive<Idx> where Idx: Clone,`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<K, V> Clone for BTreeMap<K, V> where K: Clone, V: Clone,`

[src]

####

`fn clone(&self) -> BTreeMap<K, V>`

[src]

####

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

[src]

###

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

[src]

####

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

[src]

####

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

[src]

###

`impl<P> Clone for Pin<P> where P: Clone,`

[src]

####

`fn clone(&self) -> Pin<P>`

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Bound<T> where T: Clone,`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Option<T> where T: Clone,`

[src]

####

`fn clone(&self) -> Option<T>`

[src]

####

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

[src]

###

`impl<T> Clone for Poll<T> where T: Clone,`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####

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

[src]

####

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

[src]

###

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

[src]

####

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

[src]

####

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

[src]

###

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

[src]

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Box<T> where T: Clone,`

[src]

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

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

    y.clone_from(&x);

    assert_eq!(*y, 5);Run

###

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

[src]

####

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

[src]

####

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

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

####

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

[src]

###

`impl<T> Clone for Reverse<T> where T: Clone,`

[src]

####

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

[src]

####

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

1.0.0
[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 std::collections::binary_heap::IntoIter<T> where T: Clone,`

[src]

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

####

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

[src]

###

`impl<T> Clone for BTreeSet<T> where T: Clone,`

[src]

####

`fn clone(&self) -> BTreeSet<T>`

[src]

####

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

[src]

###

`impl<T> Clone for std::collections::linked_list::IntoIter<T> where T: Clone,`

[src]

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

####

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

[src]

###

`impl<T> Clone for LinkedList<T> where T: Clone,`

[src]

####

`fn clone(&self) -> LinkedList<T>`

[src]

####

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

[src]

###

`impl<T> Clone for std::collections::vec_deque::IntoIter<T> where T: Clone,`

[src]

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

####

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

[src]

###

`impl<T> Clone for VecDeque<T> where T: Clone,`

[src]

####

`fn clone(&self) -> VecDeque<T>`

[src]

####

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

[src]

###

`impl<T> Clone for Empty<T>`

[src]

####
ⓘImportant traits for Empty<T>

### Important traits for Empty<T>

`impl<T> Iterator for Empty<T> type Item = T;`

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Once<T> where T: Clone,`

[src]

####
ⓘImportant traits for Once<T>

### Important traits for Once<T>

`impl<T> Iterator for Once<T> type Item = T;`

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Rev<T> where T: Clone,`

[src]

####
ⓘImportant traits for Rev<I>

### Important traits for Rev<I>

`impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator, type Item = <I as Iterator>::Item;`

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

[src]

####

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

[src]

###

`impl<T> Clone for PhantomData<T> where T: ?Sized,`

[src]

####

`fn clone(&self) -> PhantomData<T>`

[src]

####

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

[src]

###

`impl<T> Clone for Discriminant<T>`

[src]

####

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

[src]

####

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

1.0.0
[src]

###

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

[src]

####

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Wrapping<T> where T: Clone,`

[src]

####

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

[src]

####

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

[src]

###

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

[src]

####

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

[src]

####

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

1.0.0
[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 inner value, increasing the strong reference count.

# Examples

    use std::rc::Rc;

    let five = Rc::new(5);

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

####

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

[src]

###

`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 value.

# Examples

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

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

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

####

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

1.0.0
[src]

###

`impl<T> Clone for std::result::IntoIter<T> where T: Clone,`

[src]

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

####

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

[src]

###

`impl<T> Clone for Sender<T>`

[src]

####

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

[src]

####

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

[src]

###

`impl<T> Clone for SyncSender<T>`

[src]

####

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

[src]

####

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

[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 inner value, increasing the strong reference count.

# Examples

    use std::sync::Arc;

    let five = Arc::new(5);

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

####

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

[src]

###

`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 value.

# Examples

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

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

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

####

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

1.0.0
[src]

###

`impl<T> Clone for std::vec::IntoIter<T> where T: Clone,`

[src]

####
ⓘImportant traits for IntoIter<T>

### Important traits for IntoIter<T>

`impl<T> Iterator for IntoIter<T> type Item = T;`

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

[src]

####

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

1.0.0
[src]

###

`impl<T> Clone for Vec<T> where T: Clone,`

[src]

####
ⓘImportant traits for Vec<u8>

### Important traits for Vec<u8>

`impl Write for Vec<u8>`

`fn clone(&self) -> Vec<T>`

[src]

####

`fn clone_from(&mut self, other: &Vec<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: &Self)`

[src]

###

`impl<T: Clone> Clone for TrySendError<T>`

[src]

####

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

[src]

####

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

[src]

###

`impl<T: Clone> Clone for Cursor<T>`

[src]

####
ⓘImportant traits for Cursor<T>

### Important traits for Cursor<T>

`impl<T> Read for Cursor<T> where
T: AsRef<[u8]>, impl<'a> Write for Cursor<&'a mut [u8]>impl<'a> Write for Cursor<&'a mut Vec<u8>>impl Write for Cursor<Vec<u8>>impl Write for Cursor<Box<[u8]>>`

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

[src]

####

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

[src]

###

`impl<T: Clone> Clone for SendError<T>`

[src]

####

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

[src]

####

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

[src]

###

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

[src]

####

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

[src]

####

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

[src]

###

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

[src]

####

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

[src]

####

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

1.0.0
[src]

# Help

## Keyboard Shortcuts

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

## Search Tricks

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

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

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

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