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);
624 /// let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
626 /// let vec = unsafe {
627 /// let mem = alloc(layout).cast::<u32>();
661 /// let mut vec: Vec<i32, _> = Vec::new_in(System);
701 /// let mut vec = Vec::with_capacity_in(10, System);
721 /// let vec_units = Vec::<(), System>::with_capacity_in(10, System);
759 /// let mut vec = Vec::try_with_capacity_in(10, System).unwrap();
777 /// let mut result = Vec::try_with_capacity_in(usize::MAX, System);
782 /// let vec_units = Vec::<(), System>::try_with_capacity_in(10, System).unwrap();
846 /// let mut v = Vec::with_capacity_in(3, System);
854 /// let mut v = mem::ManuallyDrop::new(v);
857 /// let p = v.as_mut_ptr();
858 /// let len = v.len();
859 /// let cap = v.capacity();
860 /// let alloc = v.allocator();
869 /// let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
882 /// let layout = Layout::array::<u32>(16).expect("overflow cannot happen");
884 /// let vec = unsafe {
885 /// let mem = match Global.allocate(layout) {
924 /// let v: Vec<i32> = vec![-1, 0, 1];
926 /// let (ptr, len, cap) = v.into_raw_parts();
928 /// let rebuilt = unsafe {
931 /// let ptr = ptr as *mut u32;
939 let mut me = ManuallyDrop::new(self); in into_raw_parts()
964 /// let mut v: Vec<i32, System> = Vec::new_in(System);
969 /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
971 /// let rebuilt = unsafe {
974 /// let ptr = ptr as *mut u32;
983 let mut me = ManuallyDrop::new(self); in into_raw_parts_with_alloc()
984 let len = me.len(); in into_raw_parts_with_alloc()
985 let capacity = me.capacity(); in into_raw_parts_with_alloc()
986 let ptr = me.as_mut_ptr(); in into_raw_parts_with_alloc()
987 let alloc = unsafe { ptr::read(me.allocator()) }; in into_raw_parts_with_alloc()
997 /// let mut vec: Vec<i32> = Vec::with_capacity(10);
1020 /// let mut vec = vec![1];
1050 /// let mut vec = vec![1];
1078 /// let mut output = Vec::new();
1121 /// let mut output = Vec::new();
1148 /// let mut vec = Vec::with_capacity(10);
1175 /// let mut vec = Vec::with_capacity(10);
1201 /// let v = vec![1, 2, 3];
1203 /// let slice = v.into_boxed_slice();
1209 /// let mut vec = Vec::with_capacity(10);
1213 /// let slice = vec.into_boxed_slice();
1221 let me = ManuallyDrop::new(self); in into_boxed_slice()
1222 let buf = ptr::read(&me.buf); in into_boxed_slice()
1223 let len = me.len(); in into_boxed_slice()
1245 /// let mut vec = vec![1, 2, 3, 4, 5];
1254 /// let mut vec = vec![1, 2, 3];
1263 /// let mut vec = vec![1, 2, 3];
1286 let remaining_len = self.len - len; in truncate()
1287 let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len); in truncate()
1301 /// let buffer = vec![1, 2, 3, 5, 8];
1318 /// let mut buffer = vec![0; 3];
1351 /// let x = vec![1, 2, 4];
1352 /// let x_ptr = x.as_ptr();
1365 /// let mut v = vec![0, 1, 2];
1366 /// let ptr1 = v.as_ptr();
1367 /// let _ = ptr1.read();
1368 /// let ptr2 = v.as_mut_ptr().offset(2);
1372 /// let _ = ptr1.read();
1408 /// let size = 4;
1409 /// let mut x: Vec<i32> = Vec::with_capacity(size);
1410 /// let x_ptr = x.as_mut_ptr();
1426 /// let mut v = vec![0];
1427 /// let ptr1 = v.as_mut_ptr();
1429 /// let ptr2 = v.as_mut_ptr();
1494 /// let mut dict = Vec::with_capacity(32_768);
1495 /// let mut dict_length = 0;
1502 /// let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
1519 /// let mut vec = vec![vec![1, 0, 0],
1556 /// let mut v = vec!["foo", "bar", "baz", "qux"];
1573 let len = self.len(); in swap_remove()
1581 let value = ptr::read(self.as_ptr().add(index)); in swap_remove()
1582 let base_ptr = self.as_mut_ptr(); in swap_remove()
1599 /// let mut vec = vec![1, 2, 3];
1614 let len = self.len(); in insert()
1625 let p = self.as_mut_ptr().add(index); in insert()
1662 /// let mut v = vec![1, 2, 3];
1676 let len = self.len(); in remove()
1682 let ret; in remove()
1685 let ptr = self.as_mut_ptr().add(index); in remove()
1707 /// let mut vec = vec![1, 2, 3, 4];
1716 /// let mut vec = vec![1, 2, 3, 4, 5];
1717 /// let keep = [false, true, true, false, true];
1718 /// let mut iter = keep.iter();
1739 /// let mut vec = vec![1, 2, 3, 4];
1753 let original_len = self.len(); in retain_mut()
1795 let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len }; in retain_mut()
1806 let cur = unsafe { &mut *g.v.as_mut_ptr().add(g.processed_len) }; in retain_mut()
1824 let hole_slot = g.v.as_mut_ptr().add(g.processed_len - g.deleted_cnt); in retain_mut()
1850 /// let mut vec = vec![10, 20, 21, 30, 20];
1878 /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
1889 let len = self.len(); in dedup_by()
1915 let ptr = self.vec.as_mut_ptr(); in dedup_by()
1916 let len = self.vec.len(); in dedup_by()
1920 let items_left = len.wrapping_sub(self.read); in dedup_by()
1923 let dropped_ptr = ptr.add(self.write); in dedup_by()
1925 let valid_ptr = ptr.add(self.read); in dedup_by()
1933 let dropped = self.read.wrapping_sub(self.write); in dedup_by()
1940 let mut gap = FillGapOnDrop { read: 1, write: 1, vec: self }; in dedup_by()
1941 let ptr = gap.vec.as_mut_ptr(); in dedup_by()
1950 let read_ptr = ptr.add(gap.read); in dedup_by()
1951 let prev_ptr = ptr.add(gap.write.wrapping_sub(1)); in dedup_by()
1959 let write_ptr = ptr.add(gap.write); in dedup_by()
1972 /* Technically we could let `gap` clean up with its Drop, but in dedup_by()
1989 /// let mut vec = vec![1, 2];
2003 let end = self.as_mut_ptr().add(self.len); in push()
2014 /// let mut vec = vec![1, 2];
2025 let end = self.as_mut_ptr().add(self.len); in try_push()
2051 /// let mut vec = Vec::new();
2053 /// if let Err(value) = vec.push_within_capacity(value) {
2056 /// let _ = vec.push_within_capacity(value);
2070 let end = self.as_mut_ptr().add(self.len); in push_within_capacity()
2088 /// let mut vec = vec![1, 2, 3];
2114 /// let mut vec = vec![1, 2, 3];
2115 /// let mut vec2 = vec![4, 5, 6];
2134 let count = unsafe { (*other).len() }; in append_elements()
2136 let len = self.len(); in append_elements()
2144 let count = unsafe { (*other).len() }; in try_append_elements()
2146 let len = self.len(); in try_append_elements()
2173 /// let mut v = vec![1, 2, 3];
2174 /// let u: Vec<_> = v.drain(1..).collect();
2197 let len = self.len(); in drain()
2198 let Range { start, end } = slice::range(range, ..len); in drain()
2203 let range_slice = slice::from_raw_parts(self.as_ptr().add(start), end - start); in drain()
2221 /// let mut v = vec![1, 2, 3];
2230 let elems: *mut [T] = self.as_mut_slice(); in clear()
2250 /// let a = vec![1, 2, 3];
2264 /// let mut v = Vec::new();
2288 /// let mut vec = vec![1, 2, 3];
2289 /// let vec2 = vec.split_off(1);
2319 let other_len = self.len - at; in split_off()
2320 let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); in split_off()
2349 /// let mut vec = vec![1, 2, 3];
2353 /// let mut vec = vec![];
2354 /// let mut p = 1;
2364 let len = self.len(); in resize_with()
2390 /// let x = vec![1, 2, 3];
2391 /// let static_ref: &'static mut [usize] = x.leak();
2401 let mut me = ManuallyDrop::new(self); in leak()
2418 /// let mut v = Vec::with_capacity(10);
2421 /// let uninit = v.spare_capacity_mut();
2476 /// let mut v = vec![1, 1, 2];
2481 /// let (init, uninit) = v.split_at_spare_mut();
2482 /// let sum = init.iter().copied().sum::<u32>();
2492 /// let len = v.len();
2503 let (init, spare, _) = unsafe { self.split_at_spare_mut_with_len() }; in split_at_spare_mut()
2513 let ptr = self.as_mut_ptr(); in split_at_spare_mut_with_len()
2518 let spare_ptr = unsafe { ptr.add(self.len) }; in split_at_spare_mut_with_len()
2519 let spare_ptr = spare_ptr.cast::<MaybeUninit<T>>(); in split_at_spare_mut_with_len()
2520 let spare_len = self.buf.capacity() - self.len; in split_at_spare_mut_with_len()
2526 let initialized = slice::from_raw_parts_mut(ptr, self.len); in split_at_spare_mut_with_len()
2527 let spare = slice::from_raw_parts_mut(spare_ptr, spare_len); in split_at_spare_mut_with_len()
2550 /// let mut vec = vec!["hello"];
2554 /// let mut vec = vec![1, 2, 3, 4];
2561 let len = self.len(); in resize()
2585 /// let mut vec = vec!["hello"];
2589 /// let mut vec = vec![1, 2, 3, 4];
2593 /// let mut vec = vec![42];
2594 /// let result = vec.try_resize(usize::MAX, 0);
2599 let len = self.len(); in try_resize()
2622 /// let mut vec = vec![1];
2647 /// let mut vec = vec![1];
2668 /// let mut vec = vec![0, 1, 2, 3, 4];
2685 let range = slice::range(src, ..self.len()); in extend_from_within()
2712 /// let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
2715 /// let mut flattened = vec.into_flattened();
2720 let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc(); in into_flattened()
2721 let (new_len, new_cap) = if T::IS_ZST { in into_flattened()
2748 let mut ptr = self.as_mut_ptr().add(self.len()); in extend_with()
2752 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_with()
2777 let mut ptr = self.as_mut_ptr().add(self.len()); in try_extend_with()
2781 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_with()
2812 /// let mut vec = vec![1, 2, 2, 3, 2];
2855 let (this, spare, len) = unsafe { self.split_at_spare_mut_with_len() }; in spec_extend_from_within()
2859 let to_clone = unsafe { this.get_unchecked(src) }; in spec_extend_from_within()
2872 let count = src.len(); in spec_extend_from_within()
2874 let (init, spare) = self.split_at_spare_mut(); in spec_extend_from_within()
2878 let source = unsafe { init.get_unchecked(src) }; in spec_extend_from_within()
2925 let alloc = self.allocator().clone(); in clone()
2935 let alloc = self.allocator().clone(); in clone()
2950 /// let b = std::collections::hash_map::RandomState::new();
2951 /// let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
2952 /// let s: &[u8] = &[0xa8, 0x3c, 0x09];
3010 /// let v = vec!["a".to_string(), "b".to_string()];
3011 /// let mut v_iter = v.into_iter();
3013 /// let first_element: Option<String> = v_iter.next();
3022 let mut me = ManuallyDrop::new(self); in into_iter()
3023 let alloc = ManuallyDrop::new(ptr::read(me.allocator())); in into_iter()
3024 let begin = me.as_mut_ptr(); in into_iter()
3025 let end = if T::IS_ZST { in into_iter()
3030 let cap = me.buf.capacity(); in into_iter()
3094 while let Some(element) = iterator.next() { in extend_desugared()
3095 let len = self.len(); in extend_desugared()
3097 let (lower, _) = iterator.size_hint(); in extend_desugared()
3120 while let Some(element) = iterator.next() { in try_extend_desugared()
3121 let len = self.len(); in try_extend_desugared()
3123 let (lower, _) = iterator.size_hint(); in try_extend_desugared()
3142 let (low, high) = iterator.size_hint(); in extend_trusted()
3143 if let Some(additional) = high { in extend_trusted()
3152 let ptr = self.as_mut_ptr(); in extend_trusted()
3153 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_trusted()
3175 let (low, high) = iterator.size_hint(); in try_extend_trusted()
3176 if let Some(additional) = high { in try_extend_trusted()
3185 let ptr = self.as_mut_ptr(); in try_extend_trusted()
3186 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_trusted()
3228 /// let mut v = vec![1, 2, 3, 4];
3229 /// let new = [7, 8, 9];
3230 /// let u: Vec<_> = v.splice(1..3, new).collect();
3260 /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };
3261 /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
3262 /// let mut i = 0;
3265 /// let val = vec.remove(i);
3287 /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
3289 /// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
3290 /// let odds = numbers;
3300 let old_len = self.len(); in extract_if()
3526 /// let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
3527 /// let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
3545 /// let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
3571 /// let mut vec = Vec::with_capacity(10);
3612 /// let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
3619 /// let mut v = String::from("hello world").into_bytes();
3622 /// let [a, b]: [_; 2] = v.try_into().unwrap();
3639 let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };