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

#[lang = "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 Clone for NonZeroU16

pub fn clone(&self) -> NonZeroU16

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

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

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

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

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

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

impl Clone for NonZeroI32

pub fn clone(&self) -> NonZeroI32

impl Clone for __m512d

pub fn clone(&self) -> __m512d

impl Clone for TryFromSliceError

pub fn clone(&self) -> TryFromSliceError

impl Clone for DecodeUtf16Error

pub fn clone(&self) -> DecodeUtf16Error

impl Clone for LayoutError

pub fn clone(&self) -> LayoutError

impl Clone for __m128d

pub fn clone(&self) -> __m128d

impl Clone for NonZeroUsize

pub fn clone(&self) -> NonZeroUsize

impl Clone for NonZeroI8

pub fn clone(&self) -> NonZeroI8

impl Clone for NonZeroIsize

pub fn clone(&self) -> NonZeroIsize

impl Clone for IntErrorKind

pub fn clone(&self) -> IntErrorKind

impl Clone for __m512i

pub fn clone(&self) -> __m512i

impl Clone for __m128bh

pub fn clone(&self) -> __m128bh

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

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

impl Clone for ParseIntError

pub fn clone(&self) -> ParseIntError

impl Clone for __m128i

pub fn clone(&self) -> __m128i

impl Clone for Ordering

pub fn clone(&self) -> Ordering

impl Clone for TraitObject

pub fn clone(&self) -> TraitObject

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

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

impl Clone for __m256i

pub fn clone(&self) -> __m256i

impl Clone for NonZeroU8

pub fn clone(&self) -> NonZeroU8

impl Clone for NonZeroU32

pub fn clone(&self) -> NonZeroU32

impl Clone for ParseFloatError

pub fn clone(&self) -> ParseFloatError

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

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

impl Clone for EscapeUnicode

pub fn clone(&self) -> EscapeUnicode

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

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

impl Clone for PhantomPinned

pub fn clone(&self) -> PhantomPinned

impl Clone for AllocError

pub fn clone(&self) -> AllocError

impl Clone for __m256d

pub fn clone(&self) -> __m256d

impl Clone for __m512bh

pub fn clone(&self) -> __m512bh

impl<H> Clone for BuildHasherDefault<H>

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

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

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

impl Clone for EscapeDefault

pub fn clone(&self) -> EscapeDefault

impl Clone for RawWakerVTable

pub fn clone(&self) -> RawWakerVTable

impl Clone for NonZeroU128

pub fn clone(&self) -> NonZeroU128

impl Clone for __m256

pub fn clone(&self) -> __m256

impl Clone for Duration

pub fn clone(&self) -> Duration

impl Clone for __m512

pub fn clone(&self) -> __m512

impl Clone for ToUppercase

pub fn clone(&self) -> ToUppercase

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

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

impl Clone for EscapeDebug

pub fn clone(&self) -> EscapeDebug

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

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

impl Clone for CharTryFromError

pub fn clone(&self) -> CharTryFromError

impl Clone for Waker

pub fn clone(&self) -> Waker

impl Clone for NonZeroU64

pub fn clone(&self) -> NonZeroU64

impl Clone for NonZeroI64

pub fn clone(&self) -> NonZeroI64

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

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

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

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

impl Clone for __m256bh

pub fn clone(&self) -> __m256bh

impl Clone for FpCategory

pub fn clone(&self) -> FpCategory

impl Clone for SipHasher

pub fn clone(&self) -> SipHasher

impl Clone for CpuidResult

pub fn clone(&self) -> CpuidResult

impl Clone for TypeId

pub fn clone(&self) -> TypeId

impl Clone for Layout

pub fn clone(&self) -> Layout

impl Clone for __m128

pub fn clone(&self) -> __m128

impl Clone for EscapeDefault

pub fn clone(&self) -> EscapeDefault

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 Clone for ToLowercase

pub fn clone(&self) -> ToLowercase

impl Clone for TryFromIntError

pub fn clone(&self) -> TryFromIntError

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

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

impl Clone for NonZeroI16

pub fn clone(&self) -> NonZeroI16

impl<T> Clone for Pending<T>

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

impl Clone for ParseCharError

pub fn clone(&self) -> ParseCharError

impl Clone for NonZeroI128

pub fn clone(&self) -> NonZeroI128

Loading content...

Implementors

impl Clone for !

pub fn clone(&self) -> !

impl Clone for Needed

fn clone(&self) -> Needed

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

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

pub fn clone(&self) -> Ordering

impl Clone for Infallible

pub fn clone(&self) -> Infallible

impl Clone for SearchStep

pub fn clone(&self) -> SearchStep

impl Clone for Endianness

fn clone(&self) -> Endianness

impl Clone for Error

pub fn clone(&self) -> Error

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 bool

pub fn clone(&self) -> bool

impl Clone for char

pub fn clone(&self) -> char

impl Clone for f32

pub fn clone(&self) -> f32

impl Clone for f64

pub fn clone(&self) -> f64

impl Clone for i8

pub fn clone(&self) -> i8

impl Clone for i16

pub fn clone(&self) -> i16

impl Clone for i32

pub fn clone(&self) -> i32

impl Clone for i64

pub fn clone(&self) -> i64

impl Clone for i128

pub fn clone(&self) -> i128

impl Clone for isize

pub fn clone(&self) -> isize

impl Clone for u8

pub fn clone(&self) -> u8

impl Clone for u16

pub fn clone(&self) -> u16

impl Clone for u32

pub fn clone(&self) -> u32

impl Clone for u64

pub fn clone(&self) -> u64

impl Clone for u128

pub fn clone(&self) -> u128

impl Clone for usize

pub fn clone(&self) -> usize

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

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

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

Shared references can be cloned, but mutable references cannot!

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

Shared references can be cloned, but mutable references cannot!

pub fn clone(&self) -> &'_ 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, P> Clone for nom::lib::std::slice::SplitInclusive<'_, T, P> where
    P: Clone + FnMut(&T) -> bool, 

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

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 EscapeAscii<'a>

pub fn clone(&self) -> EscapeAscii<'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 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<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<Idx> Clone for 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<T> Clone for *const T where
    T: ?Sized, 

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

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

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

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 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, 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<Y, R> Clone for GeneratorState<Y, R> where
    R: Clone,
    Y: Clone, 

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

Loading content...