pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {
        unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
    }
Decomposes a `Vec<T>` into its raw components.

Returns the raw pointer to the underlying data, the length of the vector (in elements),
the allocated capacity of the data (in elements), and the allocator. These are the same
arguments in the same order as the arguments to [`from_raw_parts_in`].

After calling this function, the caller is responsible for the
memory previously managed by the `Vec`. The only way to do
this is to convert the raw pointer, length, and capacity back
into a `Vec` with the [`from_raw_parts_in`] function, allowing
the destructor to perform the cleanup.

[`from_raw_parts_in`]: Vec::from_raw_parts_in

# Examples

```
#![feature(allocator_api, vec_into_raw_parts)]

use std::alloc::System;

let mut v: Vec<i32, System> = Vec::new_in(System);
v.push(-1);
v.push(0);
v.push(1);

let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();

let rebuilt = unsafe {
// We can now
benchmarks/haystacks/code/rust-library.rs