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];
1342 /// let x = vec![1, 2, 4];
1343 /// let x_ptr = x.as_ptr();
1373 /// let size = 4;
1374 /// let mut x: Vec<i32> = Vec::with_capacity(size);
1375 /// let x_ptr = x.as_mut_ptr();
1441 /// let mut dict = Vec::with_capacity(32_768);
1442 /// let mut dict_length = 0;
1449 /// let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
1466 /// let mut vec = vec![vec![1, 0, 0],
1503 /// let mut v = vec!["foo", "bar", "baz", "qux"];
1520 let len = self.len(); in swap_remove()
1528 let value = ptr::read(self.as_ptr().add(index)); in swap_remove()
1529 let base_ptr = self.as_mut_ptr(); in swap_remove()
1546 /// let mut vec = vec![1, 2, 3];
1561 let len = self.len(); in insert()
1572 let p = self.as_mut_ptr().add(index); in insert()
1609 /// let mut v = vec![1, 2, 3];
1623 let len = self.len(); in remove()
1629 let ret; in remove()
1632 let ptr = self.as_mut_ptr().add(index); in remove()
1654 /// let mut vec = vec![1, 2, 3, 4];
1663 /// let mut vec = vec![1, 2, 3, 4, 5];
1664 /// let keep = [false, true, true, false, true];
1665 /// let mut iter = keep.iter();
1686 /// let mut vec = vec![1, 2, 3, 4];
1700 let original_len = self.len(); in retain_mut()
1742 let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len }; in retain_mut()
1753 let cur = unsafe { &mut *g.v.as_mut_ptr().add(g.processed_len) }; in retain_mut()
1771 let hole_slot = g.v.as_mut_ptr().add(g.processed_len - g.deleted_cnt); in retain_mut()
1797 /// let mut vec = vec![10, 20, 21, 30, 20];
1825 /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
1836 let len = self.len(); in dedup_by()
1862 let ptr = self.vec.as_mut_ptr(); in dedup_by()
1863 let len = self.vec.len(); in dedup_by()
1867 let items_left = len.wrapping_sub(self.read); in dedup_by()
1870 let dropped_ptr = ptr.add(self.write); in dedup_by()
1872 let valid_ptr = ptr.add(self.read); in dedup_by()
1880 let dropped = self.read.wrapping_sub(self.write); in dedup_by()
1887 let mut gap = FillGapOnDrop { read: 1, write: 1, vec: self }; in dedup_by()
1888 let ptr = gap.vec.as_mut_ptr(); in dedup_by()
1897 let read_ptr = ptr.add(gap.read); in dedup_by()
1898 let prev_ptr = ptr.add(gap.write.wrapping_sub(1)); in dedup_by()
1906 let write_ptr = ptr.add(gap.write); in dedup_by()
1919 /* Technically we could let `gap` clean up with its Drop, but in dedup_by()
1936 /// let mut vec = vec![1, 2];
1950 let end = self.as_mut_ptr().add(self.len); in push()
1961 /// let mut vec = vec![1, 2];
1972 let end = self.as_mut_ptr().add(self.len); in try_push()
1998 /// let mut vec = Vec::new();
2000 /// if let Err(value) = vec.push_within_capacity(value) {
2003 /// let _ = vec.push_within_capacity(value);
2017 let end = self.as_mut_ptr().add(self.len); in push_within_capacity()
2035 /// let mut vec = vec![1, 2, 3];
2061 /// let mut vec = vec![1, 2, 3];
2062 /// let mut vec2 = vec![4, 5, 6];
2081 let count = unsafe { (*other).len() }; in append_elements()
2083 let len = self.len(); in append_elements()
2091 let count = unsafe { (*other).len() }; in try_append_elements()
2093 let len = self.len(); in try_append_elements()
2120 /// let mut v = vec![1, 2, 3];
2121 /// let u: Vec<_> = v.drain(1..).collect();
2144 let len = self.len(); in drain()
2145 let Range { start, end } = slice::range(range, ..len); in drain()
2150 let range_slice = slice::from_raw_parts(self.as_ptr().add(start), end - start); in drain()
2168 /// let mut v = vec![1, 2, 3];
2177 let elems: *mut [T] = self.as_mut_slice(); in clear()
2197 /// let a = vec![1, 2, 3];
2211 /// let mut v = Vec::new();
2235 /// let mut vec = vec![1, 2, 3];
2236 /// let vec2 = vec.split_off(1);
2266 let other_len = self.len - at; in split_off()
2267 let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); in split_off()
2296 /// let mut vec = vec![1, 2, 3];
2300 /// let mut vec = vec![];
2301 /// let mut p = 1;
2311 let len = self.len(); in resize_with()
2337 /// let x = vec![1, 2, 3];
2338 /// let static_ref: &'static mut [usize] = x.leak();
2348 let mut me = ManuallyDrop::new(self); in leak()
2365 /// let mut v = Vec::with_capacity(10);
2368 /// let uninit = v.spare_capacity_mut();
2423 /// let mut v = vec![1, 1, 2];
2428 /// let (init, uninit) = v.split_at_spare_mut();
2429 /// let sum = init.iter().copied().sum::<u32>();
2439 /// let len = v.len();
2450 let (init, spare, _) = unsafe { self.split_at_spare_mut_with_len() }; in split_at_spare_mut()
2460 let ptr = self.as_mut_ptr(); in split_at_spare_mut_with_len()
2465 let spare_ptr = unsafe { ptr.add(self.len) }; in split_at_spare_mut_with_len()
2466 let spare_ptr = spare_ptr.cast::<MaybeUninit<T>>(); in split_at_spare_mut_with_len()
2467 let spare_len = self.buf.capacity() - self.len; in split_at_spare_mut_with_len()
2473 let initialized = slice::from_raw_parts_mut(ptr, self.len); in split_at_spare_mut_with_len()
2474 let spare = slice::from_raw_parts_mut(spare_ptr, spare_len); in split_at_spare_mut_with_len()
2497 /// let mut vec = vec!["hello"];
2501 /// let mut vec = vec![1, 2, 3, 4];
2508 let len = self.len(); in resize()
2532 /// let mut vec = vec!["hello"];
2536 /// let mut vec = vec![1, 2, 3, 4];
2540 /// let mut vec = vec![42];
2541 /// let result = vec.try_resize(usize::MAX, 0);
2546 let len = self.len(); in try_resize()
2569 /// let mut vec = vec![1];
2594 /// let mut vec = vec![1];
2615 /// let mut vec = vec![0, 1, 2, 3, 4];
2632 let range = slice::range(src, ..self.len()); in extend_from_within()
2659 /// let mut vec = vec![[1, 2, 3], [4, 5, 6], [7, 8, 9]];
2662 /// let mut flattened = vec.into_flattened();
2667 let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc(); in into_flattened()
2668 let (new_len, new_cap) = if T::IS_ZST { in into_flattened()
2695 let mut ptr = self.as_mut_ptr().add(self.len()); in extend_with()
2699 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_with()
2724 let mut ptr = self.as_mut_ptr().add(self.len()); in try_extend_with()
2728 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_with()
2759 /// let mut vec = vec![1, 2, 2, 3, 2];
2802 let (this, spare, len) = unsafe { self.split_at_spare_mut_with_len() }; in spec_extend_from_within()
2806 let to_clone = unsafe { this.get_unchecked(src) }; in spec_extend_from_within()
2819 let count = src.len(); in spec_extend_from_within()
2821 let (init, spare) = self.split_at_spare_mut(); in spec_extend_from_within()
2825 let source = unsafe { init.get_unchecked(src) }; in spec_extend_from_within()
2872 let alloc = self.allocator().clone(); in clone()
2882 let alloc = self.allocator().clone(); in clone()
2897 /// let b = std::collections::hash_map::RandomState::new();
2898 /// let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
2899 /// let s: &[u8] = &[0xa8, 0x3c, 0x09];
2957 /// let v = vec!["a".to_string(), "b".to_string()];
2958 /// let mut v_iter = v.into_iter();
2960 /// let first_element: Option<String> = v_iter.next();
2969 let mut me = ManuallyDrop::new(self); in into_iter()
2970 let alloc = ManuallyDrop::new(ptr::read(me.allocator())); in into_iter()
2971 let begin = me.as_mut_ptr(); in into_iter()
2972 let end = if T::IS_ZST { in into_iter()
2977 let cap = me.buf.capacity(); in into_iter()
3041 while let Some(element) = iterator.next() { in extend_desugared()
3042 let len = self.len(); in extend_desugared()
3044 let (lower, _) = iterator.size_hint(); in extend_desugared()
3067 while let Some(element) = iterator.next() { in try_extend_desugared()
3068 let len = self.len(); in try_extend_desugared()
3070 let (lower, _) = iterator.size_hint(); in try_extend_desugared()
3089 let (low, high) = iterator.size_hint(); in extend_trusted()
3090 if let Some(additional) = high { in extend_trusted()
3099 let ptr = self.as_mut_ptr(); in extend_trusted()
3100 let mut local_len = SetLenOnDrop::new(&mut self.len); in extend_trusted()
3122 let (low, high) = iterator.size_hint(); in try_extend_trusted()
3123 if let Some(additional) = high { in try_extend_trusted()
3132 let ptr = self.as_mut_ptr(); in try_extend_trusted()
3133 let mut local_len = SetLenOnDrop::new(&mut self.len); in try_extend_trusted()
3175 /// let mut v = vec![1, 2, 3, 4];
3176 /// let new = [7, 8, 9];
3177 /// let u: Vec<_> = v.splice(1..3, new).collect();
3207 /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };
3208 /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
3209 /// let mut i = 0;
3212 /// let val = vec.remove(i);
3234 /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
3236 /// let evens = numbers.extract_if(|x| *x % 2 == 0).collect::<Vec<_>>();
3237 /// let odds = numbers;
3247 let old_len = self.len(); in extract_if()
3443 /// let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
3444 /// let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
3462 /// let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
3488 /// let mut vec = Vec::with_capacity(10);
3529 /// let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
3536 /// let mut v = String::from("hello world").into_bytes();
3539 /// let [a, b]: [_; 2] = v.try_into().unwrap();
3556 let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };