Lines Matching full:let
16 //! let v: Vec<i32> = Vec::new();
22 //! let v: Vec<i32> = vec![];
24 //! let v = vec![1, 2, 3, 4, 5];
26 //! let v = vec![0; 10]; // ten zeroes
33 //! let mut v = vec![1, 2];
41 //! let mut v = vec![1, 2];
43 //! let two = v.pop();
49 //! let mut v = vec![1, 2, 3];
50 //! let three = v[2];
155 /// let mut vec = Vec::new();
179 /// let mut vec1 = vec![1, 2, 3];
181 /// let vec2 = Vec::from([1, 2, 3, 4]);
190 /// let vec = vec![0; 5];
194 /// let mut vec = Vec::with_capacity(5);
205 /// let mut stack = Vec::new();
211 /// while let Some(top) = stack.pop() {
223 /// let v = vec![0, 2, 4, 6];
231 /// let v = vec![0, 2, 4, 6];
248 /// let v = vec![0, 1];
253 /// let u: &[usize] = &v;
255 /// let u: &[_] = &v;
417 /// let mut vec: Vec<i32> = Vec::new();
454 /// let mut vec = Vec::with_capacity(10);
474 /// let vec_units = Vec::<()>::with_capacity(10);
508 /// let mut vec = Vec::try_with_capacity(10).unwrap();
526 /// let mut result = Vec::try_with_capacity(usize::MAX);
531 /// let vec_units = Vec::<()>::try_with_capacity(10).unwrap();
594 /// let v = vec![1, 2, 3];
599 /// let mut v = mem::ManuallyDrop::new(v);
602 /// let p = v.as_mut_ptr();
603 /// let len = v.len();
604 /// let cap = v.capacity();
613 /// let rebuilt = Vec::from_raw_parts(p, len, cap);
626 /// let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
628 /// let vec = unsafe {
629 /// let mem = match Global.allocate(layout) {
663 /// let mut vec: Vec<i32, _> = Vec::new_in(System);
703 /// let mut vec = Vec::with_capacity_in(10, System);
723 /// let vec_units = Vec::<(), System>::with_capacity_in(10, System);
761 /// let mut vec = Vec::try_with_capacity_in(10, System).unwrap();
779 /// let mut result = Vec::try_with_capacity_in(usize::MAX, System);
784 /// let vec_units = Vec::<(), System>::try_with_capacity_in(10, System).unwrap();
848 /// let mut v = Vec::with_capacity_in(3, System);
856 /// let mut v = mem::ManuallyDrop::new(v);
859 /// let p = v.as_mut_ptr();
860 /// let len = v.len();
861 /// let cap = v.capacity();
862 /// let alloc = v.allocator();
871 /// let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
882 /// let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
883 /// let vec = unsafe {
884 /// let mem = alloc(layout).cast::<u32>();
923 /// let v: Vec<i32> = vec![-1, 0, 1];
925 /// let (ptr, len, cap) = v.into_raw_parts();
927 /// let rebuilt = unsafe {
930 /// let ptr = ptr as *mut u32;
938 let mut me = ManuallyDrop::new(self); in into_raw_parts()
963 /// let mut v: Vec<i32, System> = Vec::new_in(System);
968 /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
970 /// let rebuilt = unsafe {
973 /// let ptr = ptr as *mut u32;
982 let mut me = ManuallyDrop::new(self); in into_raw_parts_with_alloc()
983 let len = me.len(); in into_raw_parts_with_alloc()
984 let capacity = me.capacity(); in into_raw_parts_with_alloc()
985 let ptr = me.as_mut_ptr(); in into_raw_parts_with_alloc()
986 let alloc = unsafe { ptr::read(me.allocator()) }; in into_raw_parts_with_alloc()
996 /// let mut vec: Vec<i32> = Vec::with_capacity(10);
1019 /// let mut vec = vec![1];
1049 /// let mut vec = vec![1];
1077 /// let mut output = Vec::new();
1120 /// let mut output = Vec::new();
1147 /// let mut vec = Vec::with_capacity(10);
1174 /// let mut vec = Vec::with_capacity(10);
1200 /// let v = vec![1, 2, 3];
1202 /// let slice = v.into_boxed_slice();
1208 /// let mut vec = Vec::with_capacity(10);
1212 /// let slice = vec.into_boxed_slice();
1220 let me = ManuallyDrop::new(self); in into_boxed_slice()
1221 let buf = ptr::read(&me.buf); in into_boxed_slice()
1222 let len = me.len(); in into_boxed_slice()
1244 /// let mut vec = vec![1, 2, 3, 4, 5];
1253 /// let mut vec = vec![1, 2, 3];
1262 /// let mut vec = vec![1, 2, 3];
1285 let remaining_len = self.len - len; in truncate()
1286 let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len); in truncate()
1300 /// let buffer = vec![1, 2, 3, 5, 8];
1317 /// let mut buffer = vec![0; 3];
1341 /// let x = vec![1, 2, 4];
1342 /// let x_ptr = x.as_ptr();
1372 /// let size = 4;
1373 /// let mut x: Vec<i32> = Vec::with_capacity(size);
1374 /// let x_ptr = x.as_mut_ptr();
1440 /// let mut dict = Vec::with_capacity(32_768);
1441 /// let mut dict_length = 0;
1448 /// let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
1465 /// let mut vec = vec![vec![1, 0, 0],
1502 /// let mut v = vec!["foo", "bar", "baz", "qux"];
1519 let len = self.len(); in swap_remove()
1527 let value = ptr::read(self.as_ptr().add(index)); in swap_remove()
1528 let base_ptr = self.as_mut_ptr(); in swap_remove()
1545 /// let mut vec = vec![1, 2, 3];
1560 let len = self.len(); in insert()
1571 let p = self.as_mut_ptr().add(index); in insert()
1608 /// let mut v = vec![1, 2, 3];
1622 let len = self.len(); in remove()
1628 let ret; in remove()
1631 let ptr = self.as_mut_ptr().add(index); in remove()
1653 /// let mut vec = vec![1, 2, 3, 4];
1662 /// let mut vec = vec![1, 2, 3, 4, 5];
1663 /// let keep = [false, true, true, false, true];
1664 /// let mut iter = keep.iter();
1685 /// let mut vec = vec![1, 2, 3, 4];
1699 let original_len = self.len(); in retain_mut()
1741 let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len }; in retain_mut()
1752 let cur = unsafe { &mut *g.v.as_mut_ptr().add(g.processed_len) }; in retain_mut()
1770 let hole_slot = g.v.as_mut_ptr().add(g.processed_len - g.deleted_cnt); in retain_mut()
1796 /// let mut vec = vec![10, 20, 21, 30, 20];
1824 /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
1835 let len = self.len(); in dedup_by()
1861 let ptr = self.vec.as_mut_ptr(); in dedup_by()
1862 let len = self.vec.len(); in dedup_by()
1866 let items_left = len.wrapping_sub(self.read); in dedup_by()
1869 let dropped_ptr = ptr.add(self.write); in dedup_by()
1871 let valid_ptr = ptr.add(self.read); in dedup_by()
1879 let dropped = self.read.wrapping_sub(self.write); in dedup_by()
1886 let mut gap = FillGapOnDrop { read: 1, write: 1, vec: self }; in dedup_by()
1887 let ptr = gap.vec.as_mut_ptr(); in dedup_by()
1896 let read_ptr = ptr.add(gap.read); in dedup_by()
1897 let prev_ptr = ptr.add(gap.write.wrapping_sub(1)); in dedup_by()
1905 let write_ptr = ptr.add(gap.write); in dedup_by()
1918 /* Technically we could let `gap` clean up with its Drop, but in dedup_by()
1935 /// let mut vec = vec![1, 2];
1949 let end = self.as_mut_ptr().add(self.len); in push()
1960 /// let mut vec = vec![1, 2];
1971 let end = self.as_mut_ptr().add(self.len); in try_push()
1997 /// let mut vec = Vec::new();
1999 /// if let Err(value) = vec.push_within_capacity(value) {
2002 /// let _ = vec.push_within_capacity(value);
2016 let end = self.as_mut_ptr().add(self.len); in push_within_capacity()
2034 /// let mut vec = vec![1, 2, 3];
2060 /// let mut vec = vec![1, 2, 3];
2061 /// let mut vec2 = vec![4, 5, 6];
2080 let count = unsafe { (*other).len() }; in append_elements()
2082 let len = self.len(); in append_elements()
2090 let count = unsafe { (*other).len() }; in try_append_elements()
2092 let len = self.len(); in try_append_elements()
2119 /// let mut v = vec![1, 2, 3];
2120 /// let u: Vec<_> = v.drain(1..).collect();
2143 let len = self.len(); in drain()
2144 let Range { start, end } = slice::range(range, ..len); in drain()
2149 let range_slice = slice::from_raw_parts(self.as_ptr().add(start), end - start); in drain()
2167 /// let mut v = vec![1, 2, 3];
2176 let elems: *mut [T] = self.as_mut_slice(); in clear()
2196 /// let a = vec![1, 2, 3];
2210 /// let mut v = Vec::new();
2234 /// let mut vec = vec![1, 2, 3];
2235 /// let vec2 = vec.split_off(1);
2265 let other_len = self.len - at; in split_off()
2266 let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); in split_off()
2295 /// let mut vec = vec![1, 2, 3];
2299 /// let mut vec = vec![];
2300 /// let mut p = 1;
2310 let len = self.len(); in resize_with()
2336 /// let x = vec![1, 2, 3];
2337 /// let static_ref: &'static mut [usize] = x.leak();
2347 let mut me = ManuallyDrop::new(self); in leak()
2364 /// let mut v = Vec::with_capacity(10);
2367 /// let uninit = v.spare_capacity_mut();
2422 /// let mut v = vec![1, 1, 2];
2427 /// let (init, uninit) = v.split_at_spare_mut();
2428 /// let sum = init.iter().copied().sum::<u32>();
2438 /// let len = v.len();
2449 let (init, spare, _) = unsafe { self.split_at_spare_mut_with_len() }; in split_at_spare_mut()
2459 let ptr = self.as_mut_ptr(); in split_at_spare_mut_with_len()
2464 let spare_ptr = unsafe { ptr.add(self.len) }; in split_at_spare_mut_with_len()
2465 let spare_ptr = spare_ptr.cast::<MaybeUninit<T>>(); in split_at_spare_mut_with_len()
2466 let spare_len = self.buf.capacity() - self.len; in split_at_spare_mut_with_len()
2472 let initialized = slice::from_raw_parts_mut(ptr, self.len); in split_at_spare_mut_with_len()
2473 let spare = slice::from_raw_parts_mut(spare_ptr, spare_len); in split_at_spare_mut_with_len()
2496 /// let mut vec = vec!["hello"];
2500 /// let mut vec = vec![1, 2, 3, 4];
2507 let len = self.len(); in resize()
2531 /// let mut vec = vec!["hello"];
2535 /// let mut vec = vec![1, 2, 3, 4];
2539 /// let mut vec = vec![42];
2540 /// let result = vec.try_resize(usize::MAX, 0);
2545 let len = self.len(); in try_resize()
2568 /// let mut vec = vec![1];
2593 /// let mut vec = vec![1];
2614 /// let mut vec = vec![0, 1, 2, 3, 4];
2631 let range = slice::range(src, ..self.len()); in extend_from_within()
2658 /// let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
2661 /// let mut flattened = vec.into_flattened();
2666 let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc(); in into_flattened()
2667 let (new_len, new_cap) = if T::IS_ZST { in into_flattened()
2710 let mut ptr = self.as_mut_ptr().add(self.len()); in extend_with()
2714 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_with()
2739 let mut ptr = self.as_mut_ptr().add(self.len()); in try_extend_with()
2743 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_with()
2774 /// let mut vec = vec![1, 2, 2, 3, 2];
2817 let (this, spare, len) = unsafe { self.split_at_spare_mut_with_len() }; in spec_extend_from_within()
2821 let to_clone = unsafe { this.get_unchecked(src) }; in spec_extend_from_within()
2834 let count = src.len(); in spec_extend_from_within()
2836 let (init, spare) = self.split_at_spare_mut(); in spec_extend_from_within()
2840 let source = unsafe { init.get_unchecked(src) }; in spec_extend_from_within()
2887 let alloc = self.allocator().clone(); in clone()
2897 let alloc = self.allocator().clone(); in clone()
2912 /// let b = std::collections::hash_map::RandomState::new();
2913 /// let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
2914 /// let s: &[u8] = &[0xa8, 0x3c, 0x09];
2972 /// let v = vec!["a".to_string(), "b".to_string()];
2973 /// let mut v_iter = v.into_iter();
2975 /// let first_element: Option<String> = v_iter.next();
2984 let mut me = ManuallyDrop::new(self); in into_iter()
2985 let alloc = ManuallyDrop::new(ptr::read(me.allocator())); in into_iter()
2986 let begin = me.as_mut_ptr(); in into_iter()
2987 let end = if T::IS_ZST { in into_iter()
2992 let cap = me.buf.capacity(); in into_iter()
3056 while let Some(element) = iterator.next() { in extend_desugared()
3057 let len = self.len(); in extend_desugared()
3059 let (lower, _) = iterator.size_hint(); in extend_desugared()
3082 while let Some(element) = iterator.next() { in try_extend_desugared()
3083 let len = self.len(); in try_extend_desugared()
3085 let (lower, _) = iterator.size_hint(); in try_extend_desugared()
3104 let (low, high) = iterator.size_hint(); in extend_trusted()
3105 if let Some(additional) = high { in extend_trusted()
3114 let ptr = self.as_mut_ptr(); in extend_trusted()
3115 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_trusted()
3137 let (low, high) = iterator.size_hint(); in try_extend_trusted()
3138 if let Some(additional) = high { in try_extend_trusted()
3147 let ptr = self.as_mut_ptr(); in try_extend_trusted()
3148 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_trusted()
3190 /// let mut v = vec![1, 2, 3, 4];
3191 /// let new = [7, 8, 9];
3192 /// let u: Vec<_> = v.splice(1..3, new).collect();
3216 /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };
3217 /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
3218 /// let mut i = 0;
3221 /// let val = vec.remove(i);
3243 /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
3245 /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
3246 /// let odds = numbers;
3256 let old_len = self.len(); in drain_filter()
3447 /// let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
3448 /// let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
3466 /// let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
3492 /// let mut vec = Vec::with_capacity(10);
3533 /// let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
3540 /// let mut v = String::from("hello world").into_bytes();
3543 /// let [a, b]: [_; 2] = v.try_into().unwrap();
3560 let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };