Lines Matching defs:clone
694 let mut dst = dst.clone();
695 dst.extend(src.clone());
742 let mut dst = dst.clone();
802 b.iter(|| src.clone());
832 let mut dst = dst.clone();
1081 v.clone()
1213 let mut vec = template.clone();
1232 let mut vec = template.clone();
1596 b.iter(|| src.clone())
1602 b.iter(|| src.clone().clear())
1608 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1615 let mut map = src.clone();
1624 b.iter(|| src.clone().into_iter().count())
1631 let mut map = src.clone();
1641 let mut map = src.clone();
1654 let mut map = src.clone();
1667 b.iter(|| src.clone())
1673 b.iter(|| src.clone().clear())
1679 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1686 let mut map = src.clone();
1695 b.iter(|| src.clone().into_iter().count())
1702 let mut map = src.clone();
1712 let mut map = src.clone();
1725 let mut map = src.clone();
1738 b.iter(|| src.clone())
1744 b.iter(|| src.clone().clear())
1750 b.iter(|| src.clone().drain_filter(|_, _| true).count())
1757 let mut map = src.clone();
1766 b.iter(|| src.clone().into_iter().count())
1773 let mut map = src.clone();
1783 let mut map = src.clone();
1796 let mut map = src.clone();
1864 b.iter(|| src.clone())
1870 b.iter(|| src.clone().clear())
1876 b.iter(|| src.clone().drain_filter(|_| true).count())
1883 let mut set = src.clone();
1892 b.iter(|| src.clone().into_iter().count())
1899 let mut set = src.clone();
1909 let mut set = src.clone();
1922 let mut set = src.clone();
1935 b.iter(|| src.clone())
1941 b.iter(|| src.clone().clear())
1947 b.iter(|| src.clone().drain_filter(|_| true).count())
1954 let mut set = src.clone();
1963 b.iter(|| src.clone().into_iter().count())
1970 let mut set = src.clone();
1980 let mut set = src.clone();
1993 let mut set = src.clone();
2025 set_bench! {is_subset_100_vs_100, is_subset, clone, [pos(100), pos(100)]}
2026 set_bench! {is_subset_100_vs_10k, is_subset, clone, [pos(100), pos(10_000)]}
2027 set_bench! {is_subset_10k_vs_100, is_subset, clone, [pos(10_000), pos(100)]}
2028 set_bench! {is_subset_10k_vs_10k, is_subset, clone, [pos(10_000), pos(10_000)]}
2269 b.iter(|| v.clone().$f());
2281 b.iter(|| v.clone().$f());
2293 let mut v = v.clone();
2314 b.iter(|| v.clone().$f(|x| x.to_string()));
2520 b.iter(|| BinaryHeap::from(vec.clone()))
2527 b.iter(|| bheap.clone().into_sorted_vec())
2569 let mut c = a.clone();
2570 let mut d = b.clone();
2577 let mut c = a.clone();
2578 let mut d = b.clone();
2723 let mut jt = it.clone();
3308 a = a.clone();
3312 a = a.clone();
3325 a = a.clone();
3336 a = a.clone();
3340 b = b.clone();
3343 b = b.clone();
3404 let vec = iter.clone().collect::<Vec<_>>();
3410 let _rc_2 = rc.clone();
3411 let _rc_3 = rc.clone();
3426 let vec = iter.clone().collect::<Vec<_>>();
3433 let _rc_2 = rc.clone();
3434 let _rc_3 = rc.clone();
3442 let vec = iter.clone().collect::<Vec<_>>();
3447 let _rc_2 = rc.clone();
3448 let _rc_3 = rc.clone();
4650 assert!(it.clone().zip(it).all(|(x, y)| x == y));
5192 assert_eq!(string.clone().into_boxed_str().into_string(), string);
5198 let data2 = data.clone().into_boxed_str().clone().into_string();
5207 match (Cow::from(owned.clone()), Cow::from(borrowed)) {
5672 let err_clone = err.clone();
5772 let (s, u) = (*p).clone();
6650 v.extend(w.clone());
6667 v.extend(w.clone()); // specializes to `append`
6783 assert_eq!(v, v.clone());
6785 let z = w.clone();
6824 let mut v = v.clone();
6841 let mut v = v.clone();
6866 let mut v = v.iter().map(|r| Wrap(r.clone())).collect::<Vec<_>>();
7465 iter_equal(it.clone(), &[1, 2, 3]);
7468 iter_equal(it.clone(), &[3, 2]);
7470 iter_equal(it.clone(), &[2]);
7472 iter_equal(it.clone(), &[]);
7631 match (Cow::from(owned.clone()), Cow::from(borrowed)) {
7860 .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) })
7912 .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) })
8615 fn clone(&self) -> Self {
8735 let mut template = vec.clone();
8814 fn clone(&self) -> Self {
8816 panic!("panic! at the clone");
8836 // This should clone&append one Panic{..} at the end, and then panic while
8923 assert_eq!("Hello, World!", borrowed1.clone() + borrowed2.clone());
8924 assert_eq!("Hello, Rustaceans!", borrowed1.clone() + owned2.clone());
8926 assert_eq!("Hi, World!", owned1.clone() + borrowed2.clone());
8927 assert_eq!("Hi, Rustaceans!", owned1.clone() + owned2.clone());
8929 if let Cow::Owned(_) = borrowed1.clone() + borrow_empty.clone() {
8932 if let Cow::Owned(_) = borrow_empty.clone() + borrowed1.clone() {
8935 if let Cow::Owned(_) = borrowed1.clone() + owned_empty.clone() {
8938 if let Cow::Owned(_) = owned_empty.clone() + borrowed1.clone() {
8951 assert_eq!("Hello, World!", borrowed.clone() + "World!");
8953 assert_eq!("Hi, World!", owned.clone() + "World!");
8955 if let Cow::Owned(_) = borrowed.clone() + "" {
8958 if let Cow::Owned(_) = borrow_empty.clone() + "Hello, " {
8961 if let Cow::Owned(_) = owned_empty.clone() + "Hello, " {
8976 let mut s = borrowed1.clone();
8977 s += borrow_empty.clone();
8982 let mut s = borrow_empty.clone();
8983 s += borrowed1.clone();
8988 let mut s = borrowed1.clone();
8989 s += owned_empty.clone();
8994 let mut s = owned_empty.clone();
8995 s += borrowed1.clone();
9016 let mut s = borrowed.clone();
9022 let mut s = borrow_empty.clone();
9028 let mut s = owned_empty.clone();
9065 a = a.clone();
9069 a = a.clone();
9082 a = a.clone();
9093 a = a.clone();
9097 b = b.clone();
9100 b = b.clone();
9157 let vec = iter.clone().collect::<Vec<_>>();
9163 let _rc_2 = rc.clone();
9164 let _rc_3 = rc.clone();
9179 let vec = iter.clone().collect::<Vec<_>>();
9186 let _rc_2 = rc.clone();
9187 let _rc_3 = rc.clone();
9195 let vec = iter.clone().collect::<Vec<_>>();
9200 let _rc_2 = rc.clone();
9201 let _rc_3 = rc.clone();
9648 let mut v = orig.clone();
9653 let mut v = orig.clone();
9658 let mut v = orig.clone();
9663 let mut v1 = orig.clone();
9664 let mut v2 = orig.clone();
9671 let mut v = orig.clone();
9734 let mut v = orig.clone();
9746 let mut v = orig.clone();
10017 let mut jt = it.clone();
10721 let data2 = data.clone().into_boxed_slice().clone().to_vec();
10727 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
10745 fn clone(&self) -> Self {
10750 Canary { count: self.count.clone(), panics: self.panics }
10755 let canary = Canary { count: drop_count.clone(), panics: false };
10756 let panic = Canary { count: drop_count.clone(), panics: true };
10761 vec![canary.clone(), canary.clone(), canary.clone(), panic, canary].into_boxed_slice();
10764 xs.clone();
11106 m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
11107 m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
11108 m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
11109 m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
11110 m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
11111 m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
11112 m!(v.clone(), [..] => ());
11255 deq.push_front(a.clone());
11256 deq.push_front(b.clone());
11257 deq.push_back(c.clone());
11259 deq.push_back(d.clone());
11261 assert_eq!((*deq.front().unwrap()).clone(), b.clone());
11262 assert_eq!((*deq.back().unwrap()).clone(), d.clone());
11263 assert_eq!(deq.pop_front().unwrap(), b.clone());
11264 assert_eq!(deq.pop_back().unwrap(), d.clone());
11265 assert_eq!(deq.pop_back().unwrap(), c.clone());
11266 assert_eq!(deq.pop_back().unwrap(), a.clone());
11268 deq.push_back(c.clone());
11270 deq.push_front(b.clone());
11272 deq.push_back(d.clone());
11274 deq.push_front(a.clone());
11276 assert_eq!(deq[0].clone(), a.clone());
11277 assert_eq!(deq[1].clone(), b.clone());
11278 assert_eq!(deq[2].clone(), c.clone());
11279 assert_eq!(deq[3].clone(), d.clone());
11724 let mut e = d.clone();
11796 let orig = ring.clone();
11815 let mut shifted = ring.clone();
12206 let mut src = src.clone();
13382 check_exact_size_iterator(heap.len(), heap.clone().into_iter());
13383 check_exact_size_iterator(heap.len(), heap.clone().into_iter_sorted());
13384 check_exact_size_iterator(heap.len(), heap.clone().drain());
13385 check_exact_size_iterator(heap.len(), heap.clone().drain_sorted());
13403 check_trusted_len(heap.len(), heap.clone().into_iter_sorted());
13404 check_trusted_len(heap.len(), heap.clone().drain_sorted());
13410 let mut sorted = data.clone();
13489 let heap = BinaryHeap::from(data.clone());
13490 let mut v = heap.clone().into_vec();
13675 assert_eq!(a.clone().into_vec(), [100, 20, 50, 1, 10, 30]);
13679 assert_eq!(a.clone().into_vec(), [100, 20, 50, 1, 10, 30]);
13683 assert_eq!(a.clone().into_vec(), [30, 20, 10, 1]);
13760 inner_data = heap.clone().into_vec();
13801 let clone = control.clone();
13804 assert_eq!(control, clone);
13900 /// This will use `clone` to duplicate an expression, so one should be careful
14402 /// Used by `Box::clone` and `Rc`/`Arc::make_mut`.
14412 unsafe { target.write(self.clone()) };
14723 /// ptr::write(self.buf.ptr().add(self.len), x.clone());
15437 /// let boxed_str = string.clone().into_boxed_str();
15555 use std::clone::Clone;
15597 tx.send(arc_v.clone()).unwrap();
15608 let y = x.clone();
15625 let w2 = w.clone();
15633 let a2 = a.clone();
15648 let _y = x.clone();
15658 let y = x.clone();
15679 let ptr = Arc::into_raw(arc.clone());
15687 let ptr = Arc::into_raw(arc.clone());
15720 let ptr = Weak::into_raw(weak.clone());
15729 let ptr = Weak::into_raw(weak.clone());
15739 let mut cow1 = cow0.clone();
15740 let mut cow2 = cow1.clone();
15763 let cow1 = cow0.clone();
15764 let cow2 = cow1.clone();
15818 let b = Arc::downgrade(&a.clone());
15855 let c = b.clone();
15868 let x = w.clone();
15874 let c = a.clone();
15902 let y = Arc::downgrade(&x.clone());
15940 let same_five = five.clone();
15951 let a2 = a.clone();
16004 fn clone(&self) -> Fail {
16008 Fail(self.0, self.1.clone())
16081 assert!(r1.clone().downcast::<u32>().is_err());
16087 assert!(r2.clone().downcast::<i32>().is_err());
16099 let a: Result<Arc<[u32; 3]>, _> = r.clone().try_into();
16102 let a: Result<Arc<[u32; 2]>, _> = r.clone().try_into();
16131 OneRef { inner: inner.clone() }
16154 let inner1 = inner.clone();
16155 let inner2 = inner1.clone();
17924 fn clone(&self) -> Self {
17925 String { vec: self.vec.clone() }
18233 /// If you want to keep using the first `String`, you can clone it and append to the clone instead:
18238 /// let c = a.clone() + &b;
18533 s.clone()
18902 self.clone()
18910 /// A clone-on-write smart pointer.
18912 /// The type `Cow` is a smart pointer providing clone-on-write functionality: it
18913 /// can enclose and provide immutable access to borrowed data, and clone the
18924 /// [`Arc::make_mut`][crate::sync::Arc::make_mut] can provide clone-on-write
18942 /// // No clone occurs because `input` doesn't need to be mutated.
18952 /// // No clone occurs because `input` is already owned.
19007 fn clone(&self) -> Self {
19020 (t, s) => *t = s.clone(),
19500 //! allocated in the heap. Invoking [`clone`][clone] on [`Rc`] produces a new
19551 //! let rc2 = rc.clone();
19553 //! let rc3 = Rc::clone(&rc);
19569 //! let a = foo.clone();
19570 //! let b = Rc::clone(&foo);
19574 //! The `Rc::clone(&from)` syntax is the most idiomatic because it conveys more explicitly
19613 //! owner: Rc::clone(&gadget_owner),
19617 //! owner: Rc::clone(&gadget_owner),
19686 //! owner: Rc::clone(&gadget_owner),
19692 //! owner: Rc::clone(&gadget_owner),
19727 //! [clone]: Clone::clone
19866 /// Gadget { self_weak: self_weak.clone(), /* ... */ }
20086 /// let _y = Rc::clone(&x);
20290 /// let y = Rc::clone(&x);
20398 /// let _also_five = Rc::clone(&five);
20438 let _rc_clone: mem::ManuallyDrop<_> = rc.clone();
20488 /// See also [`make_mut`][make_mut], which will [`clone`][clone]
20492 /// [clone]: Clone::clone
20503 /// let _y = Rc::clone(&x);
20558 /// let same_five = Rc::clone(&five);
20575 /// [`clone`] the inner value to a new allocation to ensure unique ownership. This is also
20576 /// referred to as clone-on-write.
20583 /// [`clone`]: Clone::clone
20593 /// *Rc::make_mut(&mut data) += 1; // Won't clone anything
20594 /// let mut other_data = Rc::clone(&data); // Won't clone inner data
20596 /// *Rc::make_mut(&mut data) += 1; // Won't clone anything
20597 /// *Rc::make_mut(&mut other_data) *= 2; // Won't clone anything
20624 // Gotta clone the data, there are other Rcs.
20903 /// let foo2 = Rc::clone(&foo);
20929 /// Makes a clone of the `Rc` pointer.
20941 /// let _ = Rc::clone(&five);
20944 fn clone(&self) -> Rc<T> {
20995 /// store large values, that are slow to clone, but also heavy to check for equality, causing this
21776 /// let other_weak_foo = Weak::clone(&weak_foo);
21799 /// Makes a clone of the `Weak` pointer that points to the same allocation.
21808 /// let _ = Weak::clone(&weak_five);
21811 fn clone(&self) -> Weak<T> {
21854 // clone these much in Rust thanks to ownership and move-semantics.
22106 // HACK(japaric) needed for the implementation of `Vec::clone` during testing
22167 slots[i].write(b.clone());
22727 result.push(sep.clone());
23202 /// [`Arc`] and calls [`wake`] on the clone.
23207 self.clone().wake();
23240 // Increment the reference count of the arc to clone it.
23334 /// allocated in the heap. Invoking [`clone`][clone] on `Arc` produces
23394 /// let a = foo.clone();
23395 /// let b = Arc::clone(&foo);
23422 /// let arc2 = arc.clone();
23424 /// let arc3 = Arc::clone(&arc);
23431 /// [clone]: Clone::clone
23442 /// [`Arc::clone(&from)`]: Arc::clone
23460 /// let five = Arc::clone(&five);
23480 /// let val = Arc::clone(&val);
23627 /// me: me.clone(),
23666 // - It can *clone* the `Weak`, increasing the weak reference count.
23860 /// let _y = Arc::clone(&x);
24061 /// let y = Arc::clone(&x);
24211 /// let _also_five = Arc::clone(&five);
24255 let _arc_clone: mem::ManuallyDrop<_> = arc.clone();
24326 /// let same_five = Arc::clone(&five);
24522 /// Makes a clone of the `Arc` pointer.
24534 /// let _ = Arc::clone(&five);
24537 fn clone(&self) -> Arc<T> {
24585 /// then `make_mut` will create a new allocation and invoke [`clone`][clone] on the inner value
24586 /// to ensure unique ownership. This is also referred to as clone-on-write.
24593 /// [clone]: Clone::clone
24604 /// *Arc::make_mut(&mut data) += 1; // Won't clone anything
24605 /// let mut other_data = Arc::clone(&data); // Won't clone inner data
24607 /// *Arc::make_mut(&mut data) += 1; // Won't clone anything
24608 /// *Arc::make_mut(&mut other_data) *= 2; // Won't clone anything
24626 // Another strong pointer exists, so we must clone.
24677 /// See also [`make_mut`][make_mut], which will [`clone`][clone]
24681 /// [clone]: Clone::clone
24692 /// let _y = Arc::clone(&x);
24796 /// let foo2 = Arc::clone(&foo);
25089 // See comments in `Arc::clone` for why we do this (for `mem::forget`).
25211 /// Makes a clone of the `Weak` pointer that points to the same allocation.
25220 /// let _ = Weak::clone(&weak_five);
25223 fn clone(&self) -> Weak<T> {
25229 // See comments in Arc::clone() for why this is relaxed. This can use a
25235 // See comments in Arc::clone() for why we do this (for mem::forget).
25284 /// let other_weak_foo = Weak::clone(&weak_foo);
25329 /// store large values, that are slow to clone, but also heavy to check for equality, causing this
26388 use std::clone::Clone;
26397 let y = x.clone();
26411 let y = x.clone();
26444 let b = Rc::downgrade(&a.clone());
26454 let y = x.clone();
26476 let c = b.clone();
26492 let c = a.clone();
26507 let w2 = w.clone();
26515 let a2 = a.clone();
26530 let _y = x.clone();
26540 let y = x.clone();
26561 let ptr = Rc::into_raw(rc.clone());
26569 let ptr = Rc::into_raw(rc.clone());
26602 let ptr = Weak::into_raw(weak.clone());
26611 let ptr = Weak::into_raw(weak.clone());
26623 let y = x.clone();
26634 let mut cow1 = cow0.clone();
26635 let mut cow2 = cow1.clone();
26658 let cow1 = cow0.clone();
26659 let cow2 = cow1.clone();
26701 assert_eq!(foo, foo.clone());
26737 let same_five = five.clone();
26778 fn clone(&self) -> Fail {
26782 Fail(self.0, self.1.clone())
26855 assert!(r1.clone().downcast::<u32>().is_err());
26861 assert!(r2.clone().downcast::<i32>().is_err());
26873 let a: Result<Rc<[u32; 3]>, _> = r.clone().try_into();
26876 let a: Result<Rc<[u32; 2]>, _> = r.clone().try_into();
26907 OneRef { inner: inner.clone() }
26930 TwoRefs { inner: inner.clone(), inner1: inner.clone() }
27018 fn clone(&self) -> Self {
28066 fn clone(&self) -> Self {
28679 fn clone(&self) -> Self {
28965 let mut a = v1.clone();
29294 /// Events are `clone`, `drop` or some anonymous `query`.
29370 fn clone(&self) -> Self {
29373 panic!("panic in `clone`");
29951 fn clone(&self) -> BTreeMap<K, V> {
29975 out_node.push(k.clone(), v.clone());
29993 let k = (*k).clone();
29994 let v = (*v).clone();
30080 f.debug_list().entries(self.clone()).finish()
30147 f.debug_list().entries(self.clone()).finish()
30165 f.debug_list().entries(self.clone()).finish()
30237 f.debug_list().entries(self.clone()).finish()
31141 fn clone(&self) -> Self {
31142 Iter { range: self.range.clone(), length: self.length }
31357 fn clone(&self) -> Self {
31358 Keys { inner: self.inner.clone() }
31398 fn clone(&self) -> Self {
31399 Values { inner: self.inner.clone() }
31665 fn clone(&self) -> Self {
32237 fn clone(&self) -> Self {
32238 BTreeSet { map: self.map.clone() }
32260 f.debug_tuple("Iter").field(&self.iter.clone()).finish()
33446 fn clone(&self) -> Self {
33447 Iter { iter: self.iter.clone() }
33520 fn clone(&self) -> Self {
33521 Range { iter: self.iter.clone() }
33558 fn clone(&self) -> Self {
33562 self_iter: self_iter.clone(),
33563 other_iter: other_iter.clone(),
33566 DifferenceInner::Search { self_iter: self_iter.clone(), other_set }
33568 DifferenceInner::Iterate(iter) => DifferenceInner::Iterate(iter.clone()),
33625 fn clone(&self) -> Self {
33626 SymmetricDifference(self.0.clone())
33660 fn clone(&self) -> Self {
33664 IntersectionInner::Stitch { a: a.clone(), b: b.clone() }
33667 IntersectionInner::Search { small_iter: small_iter.clone(), large_set }
33720 fn clone(&self) -> Self {
33721 Union(self.0.clone())
34302 assert_eq!(m.clone(), m);
34920 set.clone_from(&set.clone());
34975 assert_eq!(a.clone().pop_last(), Some(9));
34993 let mut set = BTreeSet::from_iter(data.clone());
35005 let mut set = BTreeSet::from_iter(data.clone());
35020 let mut set = BTreeSet::from_iter(data.clone());
35024 assert!(set.into_iter().eq(data.clone().into_iter().filter(|x| *x < key)));
36503 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36555 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36566 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36595 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36606 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36643 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36654 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36665 let mut map: BTreeMap<_, _> = pairs.clone().collect();
36676 let mut map: BTreeMap<_, _> = pairs.clone().collect();
37019 assert_eq!(map, map.clone());
37026 assert_eq!(map, map.clone());
37033 assert_eq!(map, map.clone());
37041 assert_eq!(map, map.clone());
37047 assert_eq!(map, map.clone());
37050 assert_eq!(map, map.clone());
37065 catch_unwind(|| map.clone()).unwrap_err();
37092 let mut map1_copy = map2.clone();
37095 let mut map2_copy = map1.clone();
37342 map.clone_from(&map.clone());
37547 let mut map = BTreeMap::from_iter(data.clone());
37561 let mut map = BTreeMap::from_iter(data.clone());
37576 let mut left: BTreeMap<_, _> = pairs.clone().collect();
37592 let mut left: BTreeMap<_, _> = pairs.clone().collect();
37613 let split_key = large_keys.clone().next().unwrap();
37629 let mut map = BTreeMap::from_iter(data.clone());
37635 assert!(map.into_iter().eq(data.clone().into_iter().filter(|x| x.0 < key)));
37849 fn clone(&self) -> Self {
37850 Self { a: self.a.clone(), b: self.b.clone(), peeked: self.peeked.clone() }
38123 fn clone(&self) -> Self {
38636 fn clone(&self) -> Self {
39327 /// The symmetric clone of `bulk_steal_left`.
39815 /// The symmetric clone of `fix_right_border`.
40453 fn clone(&self) -> VecDeque<T> {
42983 self.resize_with(new_len, || value.clone());
43311 fn clone(&self) -> Self {
43915 let vd = VecDeque::from(vec.clone());
43923 let vd = VecDeque::from(vec.clone());
43933 let vd = VecDeque::from(vec.clone()); // no room for +1
43950 let vec: Vec<_> = Vec::from(vd.clone());
44012 let mut v = VecDeque::from(vr.clone());
44016 let mut u = VecDeque::from(ur.clone());
44042 let v = v.clone();
44584 fn clone(&self) -> Self {
44585 BinaryHeap { data: self.data.clone() }
45473 fn clone(&self) -> Self {
45474 Iter { iter: self.iter.clone() }
46076 fn clone(&self) -> Self {
46077 self.as_slice().to_vec_in(self.alloc.clone()).into_iter()
46080 fn clone(&self) -> Self {
46081 crate::slice::to_vec(self.as_slice(), self.alloc.clone()).into_iter()
47457 /// let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
48659 Vec::with_capacity_in(self.capacity(), self.allocator().clone()),
48664 let mut other = Vec::with_capacity_in(other_len, self.allocator().clone());
48880 /// in order to be able to clone the passed value.
48971 self.0.clone()
49086 .map(|(src, dst)| dst.write(src.clone()))
49145 fn clone(&self) -> Self {
49146 let alloc = self.allocator().clone();
49155 fn clone(&self) -> Self {
49156 let alloc = self.allocator().clone();
49586 /// Convert a clone-on-write slice into a vector.
50152 Global.allocate_zeroed(layout.clone()).unwrap_or_else(|_| handle_alloc_error(layout));
51202 /// Returns a new box with a `clone()` of this box's contents.
51208 /// let y = x.clone();
51217 fn clone(&self) -> Self {
51219 let mut boxed = Self::new_uninit_in(self.1.clone());
51251 fn clone(&self) -> Self {
51749 fn clone(&self) -> Self {
51750 let alloc = Box::allocator(self).clone();
51758 *self = other.clone();
51948 use core::clone::Clone;
51958 let b: Box<i32> = a.clone();
52090 let a: Result<Box<[u32; 3]>, _> = r.clone().try_into();
52093 let a: Result<Box<[u32; 2]>, _> = r.clone().try_into();