Trait nom::lib::std::prelude::v1::rust_2015::Clone

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

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

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

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

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

Derivable

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

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

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

How can I implement Clone?

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

An example is a generic struct holding a function pointer. In this case, the implementation of Clone cannot be derived, but can be implemented as:

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

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

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

Additional implementors

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

• Function item types (i.e., the distinct types defined for each function)
• Function pointer types (e.g., fn() -> i32)
• Array types, for all sizes, if the item type also implements Clone (e.g., [i32; 123456])
• Tuple types, if each component also implements Clone (e.g., (), (i32, bool))
• Closure types, if they capture no value from the environment or if all such captured values implement Clone themselves. Note that variables captured by shared reference always implement Clone (even if the referent doesn’t), while variables captured by mutable reference never implement Clone.

Required methods

#[must_use = "cloning is often expensive and is not expected to have side effects"]

pub fn clone(&self) -> Self

Returns a copy of the value.

Examples

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

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

Loading content...

Provided methods

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

Performs copy-assignment from source.

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

Loading content...

Implementations on Foreign Types

impl<'a> Clone for Chain<'a>

pub fn clone(&self) -> Chain<'a>

impl Clone for AddrParseError

pub fn clone(&self) -> AddrParseError

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

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

impl Clone for FromVecWithNulError

pub fn clone(&self) -> FromVecWithNulError

impl Clone for AccessError

pub fn clone(&self) -> AccessError

impl Clone for SocketAddrV6

pub fn clone(&self) -> SocketAddrV6

impl Clone for Shutdown

pub fn clone(&self) -> Shutdown

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

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

impl Clone for VarError

pub fn clone(&self) -> VarError

impl Clone for SocketAddrV4

pub fn clone(&self) -> SocketAddrV4

impl Clone for SocketCred

pub fn clone(&self) -> SocketCred

impl Clone for SystemTimeError

pub fn clone(&self) -> SystemTimeError

impl Clone for WaitTimeoutResult

pub fn clone(&self) -> WaitTimeoutResult

impl Clone for PathBuf

pub fn clone(&self) -> PathBuf

pub fn clone_from(&mut self, source: &PathBuf)

impl Clone for SocketAddr

pub fn clone(&self) -> SocketAddr

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

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

impl Clone for ThreadId

pub fn clone(&self) -> ThreadId

impl Clone for Metadata

pub fn clone(&self) -> Metadata

impl<T> Clone for TrySendError<T> where
    T: Clone, 

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

impl Clone for SocketAddr

pub fn clone(&self) -> SocketAddr

impl Clone for SeekFrom

pub fn clone(&self) -> SeekFrom

impl Clone for NulError

pub fn clone(&self) -> NulError

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

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

impl Clone for Permissions

pub fn clone(&self) -> Permissions

impl Clone for ErrorKind

pub fn clone(&self) -> ErrorKind

impl<T> Clone for SyncOnceCell<T> where
    T: Clone, 

pub fn clone(&self) -> SyncOnceCell<T>

impl Clone for Thread

pub fn clone(&self) -> Thread

impl Clone for Ipv4Addr

pub fn clone(&self) -> Ipv4Addr

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

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

impl Clone for TryRecvError

pub fn clone(&self) -> TryRecvError

impl<'a> Clone for IoSlice<'a>

pub fn clone(&self) -> IoSlice<'a>

impl Clone for OpenOptions

pub fn clone(&self) -> OpenOptions

impl Clone for FromBytesWithNulError

pub fn clone(&self) -> FromBytesWithNulError

impl Clone for Instant

pub fn clone(&self) -> Instant

impl<'a> Clone for Iter<'a>

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

impl Clone for Ipv6Addr

pub fn clone(&self) -> Ipv6Addr

impl Clone for RecvTimeoutError

pub fn clone(&self) -> RecvTimeoutError

impl Clone for OsString

pub fn clone(&self) -> OsString

pub fn clone_from(&mut self, source: &OsString)

impl Clone for FileType

pub fn clone(&self) -> FileType

impl<T> Clone for SendError<T> where
    T: Clone, 

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

impl Clone for UCred

pub fn clone(&self) -> UCred

impl Clone for IpAddr

pub fn clone(&self) -> IpAddr

impl Clone for StripPrefixError

pub fn clone(&self) -> StripPrefixError

impl<T> Clone for SyncSender<T>

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

impl Clone for IntoStringError

pub fn clone(&self) -> IntoStringError

impl Clone for Output

pub fn clone(&self) -> Output

impl Clone for stat

pub fn clone(&self) -> stat

impl Clone for RecvError

pub fn clone(&self) -> RecvError

impl<T> Clone for Cursor<T> where
    T: Clone, 

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

impl Clone for CString

pub fn clone(&self) -> CString

impl Clone for ExitCode

pub fn clone(&self) -> ExitCode

impl Clone for SystemTime

pub fn clone(&self) -> SystemTime

impl Clone for Ipv6MulticastScope

pub fn clone(&self) -> Ipv6MulticastScope

impl Clone for ExitStatus

pub fn clone(&self) -> ExitStatus

impl<T> Clone for Sender<T>

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

impl Clone for FpCategory

pub fn clone(&self) -> FpCategory

impl Clone for NonZeroI16

pub fn clone(&self) -> NonZeroI16

impl Clone for bool

pub fn clone(&self) -> bool

impl Clone for TypeId

pub fn clone(&self) -> TypeId

impl Clone for u128

pub fn clone(&self) -> u128

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

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

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

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

impl Clone for NonZeroU64

pub fn clone(&self) -> NonZeroU64

impl Clone for EscapeDefault

pub fn clone(&self) -> EscapeDefault

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

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

impl Clone for NonZeroU32

pub fn clone(&self) -> NonZeroU32

impl Clone for __m512d

pub fn clone(&self) -> __m512d

impl Clone for IntErrorKind

pub fn clone(&self) -> IntErrorKind

impl Clone for u8

pub fn clone(&self) -> u8

impl<'a> Clone for EscapeAscii<'a>

pub fn clone(&self) -> EscapeAscii<'a>

impl Clone for TryFromSliceError

pub fn clone(&self) -> TryFromSliceError

impl Clone for Waker

pub fn clone(&self) -> Waker

impl Clone for __m512bh

pub fn clone(&self) -> __m512bh

impl<T> Clone for RefCell<T> where
    T: Clone, 

pub fn clone(&self) -> RefCell<T>

Panics

Panics if the value is currently mutably borrowed.

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

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

impl Clone for EscapeUnicode

pub fn clone(&self) -> EscapeUnicode

impl<T> Clone for Pending<T>

pub fn clone(&self) -> Pending<T>

impl Clone for NonZeroI128

pub fn clone(&self) -> NonZeroI128

impl Clone for ToUppercase

pub fn clone(&self) -> ToUppercase

impl Clone for Ordering

pub fn clone(&self) -> Ordering

impl Clone for ToLowercase

pub fn clone(&self) -> ToLowercase

impl Clone for __m128bh

pub fn clone(&self) -> __m128bh

impl Clone for NonZeroI64

pub fn clone(&self) -> NonZeroI64

impl Clone for i32

pub fn clone(&self) -> i32

impl Clone for ParseIntError

pub fn clone(&self) -> ParseIntError

impl Clone for NonZeroU128

pub fn clone(&self) -> NonZeroU128

impl Clone for !

pub fn clone(&self) -> !

impl<Dyn> Clone for DynMetadata<Dyn> where
    Dyn: ?Sized, 

pub fn clone(&self) -> DynMetadata<Dyn>

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

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

impl Clone for i8

pub fn clone(&self) -> i8

impl Clone for __m256

pub fn clone(&self) -> __m256

impl Clone for NonZeroI8

pub fn clone(&self) -> NonZeroI8

impl Clone for DecodeUtf16Error

pub fn clone(&self) -> DecodeUtf16Error

impl Clone for u64

pub fn clone(&self) -> u64

impl Clone for i128

pub fn clone(&self) -> i128

impl Clone for __m128i

pub fn clone(&self) -> __m128i

impl Clone for ParseCharError

pub fn clone(&self) -> ParseCharError

impl<T> Clone for OnceCell<T> where
    T: Clone, 

pub fn clone(&self) -> OnceCell<T>

impl Clone for char

pub fn clone(&self) -> char

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

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

impl Clone for __m512

pub fn clone(&self) -> __m512

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

Shared references can be cloned, but mutable references cannot!

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

impl Clone for __m256i

pub fn clone(&self) -> __m256i

impl<'f> Clone for VaListImpl<'f>

pub fn clone(&self) -> VaListImpl<'f>

impl Clone for EscapeDefault

pub fn clone(&self) -> EscapeDefault

impl Clone for isize

pub fn clone(&self) -> isize

impl<T, const N: usize> Clone for IntoIter<T, N> where
    T: Clone, 

pub fn clone(&self) -> IntoIter<T, N>

impl Clone for NonZeroI32

pub fn clone(&self) -> NonZeroI32

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

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

impl Clone for TryFromIntError

pub fn clone(&self) -> TryFromIntError

impl Clone for RawWakerVTable

pub fn clone(&self) -> RawWakerVTable

impl Clone for i64

pub fn clone(&self) -> i64

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

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

impl Clone for usize

pub fn clone(&self) -> usize

impl Clone for __m128

pub fn clone(&self) -> __m128

impl Clone for CharTryFromError

pub fn clone(&self) -> CharTryFromError

impl Clone for CpuidResult

pub fn clone(&self) -> CpuidResult

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

Shared references can be cloned, but mutable references cannot!

impl Clone for ParseFloatError

pub fn clone(&self) -> ParseFloatError

impl Clone for f32

pub fn clone(&self) -> f32

impl Clone for PhantomPinned

pub fn clone(&self) -> PhantomPinned

impl Clone for __m256bh

pub fn clone(&self) -> __m256bh

impl Clone for NonZeroU16

pub fn clone(&self) -> NonZeroU16

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

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

impl Clone for __m256d

pub fn clone(&self) -> __m256d

impl Clone for EscapeDebug

pub fn clone(&self) -> EscapeDebug

impl Clone for i16

pub fn clone(&self) -> i16

impl<T> Clone for Ready<T> where
    T: Clone, 

pub fn clone(&self) -> Ready<T>

impl Clone for f64

pub fn clone(&self) -> f64

impl Clone for TraitObject

pub fn clone(&self) -> TraitObject

impl Clone for u16

pub fn clone(&self) -> u16

impl Clone for u32

pub fn clone(&self) -> u32

impl<'a> Clone for Location<'a>

pub fn clone(&self) -> Location<'a>

impl Clone for __m512i

pub fn clone(&self) -> __m512i

impl Clone for NonZeroIsize

pub fn clone(&self) -> NonZeroIsize

impl Clone for Duration

pub fn clone(&self) -> Duration

impl Clone for NonZeroUsize

pub fn clone(&self) -> NonZeroUsize

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

pub fn clone(&self) -> SplitInclusive<'_, T, P>

impl Clone for __m128d

pub fn clone(&self) -> __m128d

impl Clone for NonZeroU8

pub fn clone(&self) -> NonZeroU8

impl<T> Clone for Weak<T> where
    T: ?Sized, 

pub fn clone(&self) -> Weak<T>

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

Examples

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

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

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

impl<T> Clone for Weak<T> where
    T: ?Sized, 

pub fn clone(&self) -> Weak<T>

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

Examples

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

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

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

impl<T> Clone for Arc<T> where
    T: ?Sized, 

pub fn clone(&self) -> Arc<T>

Makes a clone of the Arc pointer.

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

impl<T> Clone for Rc<T> where
    T: ?Sized, 

pub fn clone(&self) -> Rc<T>

Makes a clone of the Rc pointer.

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

impl Clone for _Unwind_Reason_Code

pub fn clone(&self) -> _Unwind_Reason_Code

impl Clone for _Unwind_Action

pub fn clone(&self) -> _Unwind_Action

Loading content...

Implementors

impl Clone for Needed

fn clone(&self) -> Needed

impl Clone for nom::error::ErrorKind

fn clone(&self) -> ErrorKind

impl Clone for VerboseErrorKind

fn clone(&self) -> VerboseErrorKind

impl Clone for Endianness

fn clone(&self) -> Endianness

impl Clone for nom::lib::std::cmp::Ordering

pub fn clone(&self) -> Ordering

impl Clone for TryReserveError

pub fn clone(&self) -> TryReserveError

impl Clone for Infallible

pub fn clone(&self) -> Infallible

impl Clone for SearchStep

pub fn clone(&self) -> SearchStep

impl Clone for AllocError

pub fn clone(&self) -> AllocError

impl Clone for Global

pub fn clone(&self) -> Global

impl Clone for Layout

pub fn clone(&self) -> Layout

impl Clone for LayoutError

pub fn clone(&self) -> LayoutError

impl Clone for System

pub fn clone(&self) -> System

impl Clone for Box<str, Global>

pub fn clone(&self) -> Box<str, Global>

impl Clone for Box<CStr, Global>

pub fn clone(&self) -> Box<CStr, Global>

impl Clone for Box<OsStr, Global>

pub fn clone(&self) -> Box<OsStr, Global>

impl Clone for Box<Path, Global>

pub fn clone(&self) -> Box<Path, Global>

impl Clone for DefaultHasher

pub fn clone(&self) -> DefaultHasher

impl Clone for RandomState

pub fn clone(&self) -> RandomState

impl Clone for Error

pub fn clone(&self) -> Error

impl Clone for SipHasher

pub fn clone(&self) -> SipHasher

impl Clone for RangeFull

pub fn clone(&self) -> RangeFull

impl Clone for NoneError

pub fn clone(&self) -> NoneError

impl Clone for ParseBoolError

pub fn clone(&self) -> ParseBoolError

impl Clone for Utf8Error

pub fn clone(&self) -> Utf8Error

impl Clone for FromUtf8Error

pub fn clone(&self) -> FromUtf8Error

impl Clone for String

pub fn clone(&self) -> String

pub fn clone_from(&mut self, source: &String)

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

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

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

pub fn clone(&self) -> Cow<'_, B>

pub fn clone_from(&mut self, source: &Cow<'_, B>)

impl<'_, K> Clone for nom::lib::std::collections::hash_set::Iter<'_, K>

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

impl<'_, K, V> Clone for nom::lib::std::collections::btree_map::Iter<'_, K, V>

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

impl<'_, K, V> Clone for nom::lib::std::collections::btree_map::Keys<'_, K, V>

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

impl<'_, K, V> Clone for nom::lib::std::collections::btree_map::Range<'_, K, V>

pub fn clone(&self) -> Range<'_, K, V>

impl<'_, K, V> Clone for nom::lib::std::collections::btree_map::Values<'_, K, V>

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

impl<'_, K, V> Clone for nom::lib::std::collections::hash_map::Iter<'_, K, V>

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

impl<'_, K, V> Clone for nom::lib::std::collections::hash_map::Keys<'_, K, V>

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

impl<'_, K, V> Clone for nom::lib::std::collections::hash_map::Values<'_, K, V>

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

impl<'_, T> Clone for nom::lib::std::collections::binary_heap::Iter<'_, T>

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

impl<'_, T> Clone for nom::lib::std::collections::btree_set::Difference<'_, T>

pub fn clone(&self) -> Difference<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::btree_set::Intersection<'_, T>

pub fn clone(&self) -> Intersection<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::btree_set::Iter<'_, T>

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

impl<'_, T> Clone for nom::lib::std::collections::btree_set::Range<'_, T>

pub fn clone(&self) -> Range<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::btree_set::SymmetricDifference<'_, T>

pub fn clone(&self) -> SymmetricDifference<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::btree_set::Union<'_, T>

pub fn clone(&self) -> Union<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::linked_list::Cursor<'_, T>

pub fn clone(&self) -> Cursor<'_, T>

impl<'_, T> Clone for nom::lib::std::collections::linked_list::Iter<'_, T>

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

impl<'_, T> Clone for nom::lib::std::collections::vec_deque::Iter<'_, T>

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

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

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

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

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

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

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

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

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

impl<'_, T> Clone for RChunks<'_, T>

pub fn clone(&self) -> RChunks<'_, T>

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

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

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

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

impl<'_, T, S> Clone for nom::lib::std::collections::hash_set::Difference<'_, T, S>

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

impl<'_, T, S> Clone for nom::lib::std::collections::hash_set::Intersection<'_, T, S>

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

impl<'_, T, S> Clone for nom::lib::std::collections::hash_set::SymmetricDifference<'_, T, S>

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

impl<'_, T, S> Clone for nom::lib::std::collections::hash_set::Union<'_, T, S>

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

impl<'_, T, const N: usize> Clone for ArrayChunks<'_, T, N>

pub fn clone(&self) -> ArrayChunks<'_, T, N>

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a> Clone for nom::lib::std::str::EscapeDebug<'a>

pub fn clone(&self) -> EscapeDebug<'a>

impl<'a> Clone for nom::lib::std::str::EscapeDefault<'a>

pub fn clone(&self) -> EscapeDefault<'a>

impl<'a> Clone for nom::lib::std::str::EscapeUnicode<'a>

pub fn clone(&self) -> EscapeUnicode<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn clone(&self) -> CharPredicateSearcher<'a, F>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, P> Clone for nom::lib::std::str::SplitInclusive<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: Clone, 

pub fn clone(&self) -> SplitInclusive<'a, P>

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

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

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

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

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

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

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

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

impl<'a, T, const N: usize> Clone for ArrayWindows<'a, T, N> where
    T: 'a + Clone, 

pub fn clone(&self) -> ArrayWindows<'a, T, N>

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

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

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

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

impl<A, B> Clone for nom::lib::std::iter::Chain<A, B> where
    A: Clone,
    B: Clone, 

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

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

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

impl<B, C> Clone for ControlFlow<B, C> where
    C: Clone,
    B: Clone, 

pub fn clone(&self) -> ControlFlow<B, C>

impl<E: Clone> Clone for Err<E>

fn clone(&self) -> Err<E>

impl<F> Clone for FromFn<F> where
    F: Clone, 

pub fn clone(&self) -> FromFn<F>

impl<F> Clone for OnceWith<F> where
    F: Clone, 

pub fn clone(&self) -> OnceWith<F>

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

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

impl<H> Clone for BuildHasherDefault<H>

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

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

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

impl<I> Clone for Copied<I> where
    I: Clone, 

pub fn clone(&self) -> Copied<I>

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

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

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

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

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

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

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

pub fn clone(&self) -> Intersperse<I>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<I, G> Clone for IntersperseWith<I, G> where
    I: Iterator + Clone,
    G: Clone,
    <I as Iterator>::Item: Clone, 

pub fn clone(&self) -> IntersperseWith<I, G>

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

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

impl<I, P> Clone for MapWhile<I, P> where
    I: Clone,
    P: Clone, 

pub fn clone(&self) -> MapWhile<I, P>

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

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

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

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

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

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

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, 

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

impl<I, U, F> Clone for FlatMap<I, U, F> where
    F: Clone,
    I: Clone,
    U: Clone + IntoIterator,
    <U as IntoIterator>::IntoIter: Clone, 

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

impl<I: Clone> Clone for VerboseError<I>

fn clone(&self) -> VerboseError<I>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn clone_from(&mut self, other: &HashMap<K, V, S>)

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

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

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

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

pub fn clone_from(&mut self, source: &Option<T>)

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

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

impl<T> Clone for nom::lib::std::collections::binary_heap::IntoIter<T> where
    T: Clone, 

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

impl<T> Clone for IntoIterSorted<T> where
    T: Clone, 

pub fn clone(&self) -> IntoIterSorted<T>

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

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

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

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

pub fn clone_from(&mut self, other: &BTreeSet<T>)

impl<T> Clone for BinaryHeap<T> where
    T: Clone, 

pub fn clone(&self) -> BinaryHeap<T>

pub fn clone_from(&mut self, source: &BinaryHeap<T>)

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

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

pub fn clone_from(&mut self, other: &LinkedList<T>)

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

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

pub fn clone_from(&mut self, other: &VecDeque<T>)

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

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

impl<T> Clone for Empty<T>

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

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

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

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

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

impl<T> Clone for Discriminant<T>

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

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

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

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

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

impl<T> Clone for MaybeUninit<T> where
    T: Copy, 

pub fn clone(&self) -> MaybeUninit<T>

impl<T, A> Clone for Box<[T], A> where
    T: Clone,
    A: Allocator + Clone, 

pub fn clone(&self) -> Box<[T], A>

pub fn clone_from(&mut self, other: &Box<[T], A>)

impl<T, A> Clone for Box<T, A> where
    T: Clone,
    A: Allocator + Clone, 

pub fn clone(&self) -> Box<T, A>

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

pub fn clone_from(&mut self, source: &Box<T, A>)

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

impl<T, A> Clone for nom::lib::std::vec::IntoIter<T, A> where
    T: Clone,
    A: Allocator + Clone, 

pub fn clone(&self) -> IntoIter<T, A>

impl<T, A> Clone for Vec<T, A> where
    T: Clone,
    A: Allocator + Clone, 

pub fn clone(&self) -> Vec<T, A>

pub fn clone_from(&mut self, other: &Vec<T, A>)

impl<T, E> Clone for Result<T, E> where
    E: Clone,
    T: Clone, 

pub fn clone(&self) -> Result<T, E>

pub fn clone_from(&mut self, source: &Result<T, E>)

impl<T, F> Clone for Successors<T, F> where
    F: Clone,
    T: Clone, 

pub fn clone(&self) -> Successors<T, F>

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

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

pub fn clone_from(&mut self, other: &HashSet<T, S>)

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

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

Loading content...