545     pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self {  in from_raw_parts()
692     pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {  in from_raw_parts_in()
729     pub fn into_raw_parts(self) -> (*mut T, usize, usize) {  in into_raw_parts()
773     pub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A) {  in into_raw_parts_with_alloc()
1003     pub fn into_boxed_slice(mut self) -> Box<[T], A> {  in into_boxed_slice()
1091     pub fn as_slice(&self) -> &[T] {  in as_slice()
1108     pub fn as_mut_slice(&mut self) -> &mut [T] {  in as_mut_slice()
1139     pub fn as_ptr(&self) -> *const T {  in as_ptr()
1175     pub fn as_mut_ptr(&mut self) -> *mut T {  in as_mut_ptr()
1304     pub fn swap_remove(&mut self, index: usize) -> T {  in swap_remove()
1345     pub fn insert(&mut self, index: usize, element: T) {  in insert()
1403     pub fn remove(&mut self, index: usize) -> T {  in remove()
1532         fn process_loop<F, T, A: Allocator, const DELETED: bool>(  in retain_mut()  argument
1622         F: FnMut(&mut T, &mut T) -> bool,  in dedup_by()
1731     pub fn push(&mut self, value: T) {  in push()
1784     pub fn pop(&mut self) -> Option<T> {  in pop()
1823     unsafe fn append_elements(&mut self, other: *const [T]) {  in append_elements()
1827         unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };  in append_elements()  constant
1862     pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>  in drain()  argument
2043         F: FnMut() -> T,  in resize_with()
2117     pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>] {  in spare_capacity_mut()
2182     pub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>]) {  in split_at_spare_mut()
2194     ) -> (&mut [T], &mut [MaybeUninit<T>], &mut usize) {  in split_at_spare_mut_with_len()
2242     pub fn resize(&mut self, new_len: usize, value: T) {  in resize()
2273     pub fn extend_from_slice(&mut self, other: &[T]) {  in extend_from_slice()
2338     pub fn into_flattened(self) -> Vec<T, A> {  in into_flattened()
2362     fn next(&mut self) -> T;  in next()
2363     fn last(self) -> T;  in last()
2368     fn next(&mut self) -> T {  in next()
2371     fn last(self) -> T {  in last()
2377 impl<T, F: FnMut() -> T> ExtendWith<T> for ExtendFunc<F> {  impl
2378     fn next(&mut self) -> T {  in next()
2381     fn last(mut self) -> T {  in last()
2447 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {  in from_elem()
2454 pub fn from_elem_in<T: Clone, A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {  in from_elem_in()  argument
2521     fn deref(&self) -> &[T] {  in deref()
2528     fn deref_mut(&mut self) -> &mut [T] {  in deref_mut()
2660     fn into_iter(self) -> IntoIter<T, A> {  in into_iter()
2666                 arith_offset(begin as *const i8, me.len() as isize) as *const T  in into_iter()  constant
2668                 begin.add(me.len()) as *const T  in into_iter()  constant
2688     fn into_iter(self) -> slice::Iter<'a, T> {  in into_iter()  argument
2698     fn into_iter(self) -> slice::IterMut<'a, T> {  in into_iter()  argument
2712     fn extend_one(&mut self, item: T) {  in extend_one()
2839     pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>  in drain_filter()  argument
2868     fn extend_one(&mut self, &item: &'a T) {  in extend_one()
2930     fn as_ref(&self) -> &Vec<T, A> {  in as_ref()
2937     fn as_mut(&mut self) -> &mut Vec<T, A> {  in as_mut()
2944     fn as_ref(&self) -> &[T] {  in as_ref()
2951     fn as_mut(&mut self) -> &mut [T] {  in as_mut()
2967     fn from(s: &[T]) -> Vec<T> {  in from()
2971     fn from(s: &[T]) -> Vec<T> {  in from()
2987     fn from(s: &mut [T]) -> Vec<T> {  in from()
2991     fn from(s: &mut [T]) -> Vec<T> {  in from()
3007     fn from(s: [T; N]) -> Vec<T> {  in from()
3012     fn from(s: [T; N]) -> Vec<T> {  in from()
3036     fn from(s: Cow<'a, [T]>) -> Vec<T> {  in from()
3054     fn from(s: Box<[T], A>) -> Self {  in from()
3074     fn from(v: Vec<T, A>) -> Self {  in from()
3124     fn try_from(mut vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>> {  in try_from()