diff --git a/library/alloc/src/io/cursor.rs b/library/alloc/src/io/cursor.rs
new file mode 100644
index 0000000000000..21f6b8b5b3ffd
--- /dev/null
+++ b/library/alloc/src/io/cursor.rs
@@ -0,0 +1,260 @@
+use crate::alloc::Allocator;
+use crate::boxed::Box;
+use crate::io::{
+    self, Cursor, ErrorKind, IoSlice, WriteThroughCursor, slice_write, slice_write_all,
+    slice_write_all_vectored, slice_write_vectored,
+};
+use crate::vec::Vec;
+
+/// Reserves the required space, and pads the vec with 0s if necessary.
+fn reserve_and_pad<A: Allocator>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    buf_len: usize,
+) -> io::Result<usize> {
+    let pos: usize = (*pos_mut).try_into().map_err(|_| {
+        io::const_error!(
+            ErrorKind::InvalidInput,
+            "cursor position exceeds maximum possible vector length",
+        )
+    })?;
+
+    // For safety reasons, we don't want these numbers to overflow
+    // otherwise our allocation won't be enough
+    let desired_cap = pos.saturating_add(buf_len);
+    if desired_cap > vec.capacity() {
+        // We want our vec's total capacity
+        // to have room for (pos+buf_len) bytes. Reserve allocates
+        // based on additional elements from the length, so we need to
+        // reserve the difference
+        cfg_select! {
+            no_global_oom_handling => {
+                vec.try_reserve(desired_cap - vec.len())?;
+            }
+            _ => {
+                vec.reserve(desired_cap - vec.len());
+            }
+        }
+    }
+    // Pad if pos is above the current len.
+    if pos > vec.len() {
+        let diff = pos - vec.len();
+        // Unfortunately, `resize()` would suffice but the optimiser does not
+        // realise the `reserve` it does can be eliminated. So we do it manually
+        // to eliminate that extra branch
+        let spare = vec.spare_capacity_mut();
+        debug_assert!(spare.len() >= diff);
+        // Safety: we have allocated enough capacity for this.
+        // And we are only writing, not reading
+        unsafe {
+            spare.get_unchecked_mut(..diff).fill(core::mem::MaybeUninit::new(0));
+            vec.set_len(pos);
+        }
+    }
+
+    Ok(pos)
+}
+
+/// Writes the slice to the vec without allocating.
+///
+/// # Safety
+///
+/// `vec` must have `buf.len()` spare capacity.
+unsafe fn vec_write_all_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
+where
+    A: Allocator,
+{
+    debug_assert!(vec.capacity() >= pos + buf.len());
+    unsafe { vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()) };
+    pos + buf.len()
+}
+
+/// Resizing `write_all` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+///
+/// [`Write`]: crate::io::Write
+fn vec_write_all<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    let buf_len = buf.len();
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to pos
+    unsafe {
+        pos = vec_write_all_unchecked(pos, vec, buf);
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    };
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+/// Resizing `write_all_vectored` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+///
+/// [`Write`]: crate::io::Write
+fn vec_write_all_vectored<A>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    // For safety reasons, we don't want this sum to overflow ever.
+    // If this saturates, the reserve should panic to avoid any unsound writing.
+    let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to the last pos
+    unsafe {
+        for buf in bufs {
+            pos = vec_write_all_unchecked(pos, vec, buf);
+        }
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    }
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
+impl<A> WriteThroughCursor for &mut Vec<u8, A>
+where
+    A: Allocator,
+{
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)
+    }
+
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A> WriteThroughCursor for Vec<u8, A>
+where
+    A: Allocator,
+{
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)
+    }
+
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all(pos, inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        vec_write_all_vectored(pos, inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_box_slice", since = "1.5.0")]
+impl<A> WriteThroughCursor for Box<[u8], A>
+where
+    A: Allocator,
+{
+    #[inline]
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = this.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/library/alloc/src/io/impls.rs b/library/alloc/src/io/impls.rs
index 732842bc65df7..1351d3e3ef3a1 100644
--- a/library/alloc/src/io/impls.rs
+++ b/library/alloc/src/io/impls.rs
@@ -1,7 +1,12 @@
+use crate::alloc::Allocator;
 use crate::boxed::Box;
-use crate::io::{self, Seek, SeekFrom, SizeHint};
+#[cfg(not(no_global_oom_handling))]
+use crate::collections::VecDeque;
+use crate::fmt;
+use crate::io::{self, IoSlice, Seek, SeekFrom, SizeHint, Write};
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 use crate::sync::Arc;
+use crate::vec::Vec;
 
 // =============================================================================
 // Forwarding implementations
@@ -20,6 +25,43 @@ impl<T> SizeHint for Box<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for Box<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<S: Seek + ?Sized> Seek for Box<S> {
     #[inline]
@@ -51,6 +93,148 @@ impl<S: Seek + ?Sized> Seek for Box<S> {
 // =============================================================================
 // In-memory buffer implementations
 
+/// Write is implemented for `Vec<u8>` by appending to the vector.
+/// The vector will grow as needed.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A: Allocator> Write for Vec<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        <Self as Write>::write_all(self, buf)?;
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        cfg_select! {
+            no_global_oom_handling => {
+                self.try_reserve(len)?;
+            }
+            _ => {
+                self.reserve(len);
+            }
+        }
+        for buf in bufs {
+            <Self as Write>::write_all(self, buf)?;
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        cfg_select! {
+            no_global_oom_handling => {
+                self.try_extend_from_slice_of_bytes(buf)?;
+            }
+            _ => {
+                self.extend_from_slice(buf);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
+#[cfg(not(no_global_oom_handling))]
+#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
+impl<A: Allocator> Write for VecDeque<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.extend(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        self.reserve(len);
+        for buf in bufs {
+            self.extend(&**buf);
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.extend(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
+#[stable(feature = "io_traits_arc", since = "1.73.0")]
+impl<W: Write + ?Sized> Write for Arc<W>
+where
+    for<'a> &'a W: Write,
+    W: crate::io::IoHandle,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (&**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (&**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (&**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (&**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (&**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (&**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (&**self).write_fmt(fmt)
+    }
+}
 #[cfg(all(not(no_rc), not(no_sync), target_has_atomic = "ptr"))]
 #[stable(feature = "io_traits_arc", since = "1.73.0")]
 impl<S: Seek + ?Sized> Seek for Arc<S>
diff --git a/library/alloc/src/io/mod.rs b/library/alloc/src/io/mod.rs
index 44a1d1b71d164..ef7e95ed5bd7c 100644
--- a/library/alloc/src/io/mod.rs
+++ b/library/alloc/src/io/mod.rs
@@ -1,5 +1,6 @@
 //! Traits, helpers, and type definitions for core I/O functionality.
 
+mod cursor;
 mod error;
 mod impls;
 
@@ -14,8 +15,12 @@ pub use core::io::{BorrowedBuf, BorrowedCursor};
 #[unstable(feature = "alloc_io", issue = "154046")]
 pub use core::io::{
     Chain, Cursor, Empty, Error, ErrorKind, IoSlice, IoSliceMut, Repeat, Result, Seek, SeekFrom,
-    Sink, Take, empty, repeat, sink,
+    Sink, Take, Write, empty, repeat, sink,
 };
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
-pub use core::io::{IoHandle, OsFunctions, SizeHint, chain, stream_len_default, take};
+pub use core::io::{
+    IoHandle, OsFunctions, SizeHint, WriteThroughCursor, chain, default_write_vectored,
+    slice_write, slice_write_all, slice_write_all_vectored, slice_write_vectored,
+    stream_len_default, take,
+};
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 01b4e6f938616..9f82f5be82a68 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -96,6 +96,7 @@
 #![feature(async_iterator)]
 #![feature(bstr)]
 #![feature(bstr_internals)]
+#![feature(can_vector)]
 #![feature(case_ignorable)]
 #![feature(cast_maybe_uninit)]
 #![feature(cell_get_cloned)]
@@ -180,6 +181,7 @@
 #![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
+#![feature(write_all_vectored)]
 #![feature(wtf8_internals)]
 // tidy-alphabetical-end
 //
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index c3b86a635bd0f..a5d03ef76ade6 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2938,8 +2938,26 @@ impl<T, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     unsafe fn append_elements(&mut self, other: *const [T]) {
+        self.reserve(other.len());
+        unsafe {
+            self.append_elements_unreserved(other);
+        }
+    }
+
+    /// Appends elements to `self` from other buffer, returning [`TryReserveError`] on OOM.
+    #[inline]
+    unsafe fn try_append_elements(&mut self, other: *const [T]) -> Result<(), TryReserveError> {
+        self.try_reserve(other.len())?;
+        unsafe {
+            self.append_elements_unreserved(other);
+        }
+        Ok(())
+    }
+
+    /// Appends elements to `self` from other buffer without reserving additional capacity.
+    #[inline]
+    unsafe fn append_elements_unreserved(&mut self, other: *const [T]) {
         let count = other.len();
-        self.reserve(count);
         let len = self.len();
         if count > 0 {
             unsafe {
@@ -3609,6 +3627,22 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     }
 }
 
+impl<A: Allocator> Vec<u8, A> {
+    #[cfg_attr(
+        not(no_global_oom_handling),
+        expect(
+            dead_code,
+            reason = "currently only used in IO module when global OOM handling is disabled"
+        )
+    )]
+    pub(crate) fn try_extend_from_slice_of_bytes(
+        &mut self,
+        other: &[u8],
+    ) -> Result<(), TryReserveError> {
+        unsafe { self.try_append_elements(other) }
+    }
+}
+
 impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
     /// Takes a `Vec<[T; N]>` and flattens it into a `Vec<T>`.
     ///
diff --git a/library/core/src/io/cursor.rs b/library/core/src/io/cursor.rs
index c104b426f48df..fe4def531a84a 100644
--- a/library/core/src/io/cursor.rs
+++ b/library/core/src/io/cursor.rs
@@ -1,4 +1,5 @@
-use crate::io::{self, ErrorKind, SeekFrom};
+use crate::cmp;
+use crate::io::{self, ErrorKind, IoSlice, SeekFrom, Write};
 
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
@@ -22,7 +23,7 @@ use crate::io::{self, ErrorKind, SeekFrom};
 /// [bytes]: crate::slice "slice"
 /// [`File`]: ../../std/fs/struct.File.html
 /// [`Read`]: ../../std/io/trait.Read.html
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Seek`]: crate::io::Seek
 /// [Vec]: ../../alloc/vec/struct.Vec.html
 ///
@@ -294,6 +295,144 @@ where
     }
 }
 
+/// Non-resizing [`Write::write`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
+    let pos = cmp::min(*pos_mut, slice.len() as u64);
+    let dst = &mut slice[(pos as usize)..];
+    let amt = cmp::min(buf.len(), dst.len());
+    dst[..amt].copy_from_slice(&buf[..amt]);
+    *pos_mut += amt as u64;
+    Ok(amt)
+}
+
+/// Non-resizing [`Write::write_vectored`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize> {
+    let mut nwritten = 0;
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        nwritten += n;
+        if n < buf.len() {
+            break;
+        }
+    }
+    Ok(nwritten)
+}
+
+/// Non-resizing [`Write::write_all`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_all(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<()> {
+    let n = slice_write(pos_mut, slice, buf)?;
+    if n < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+}
+
+/// Non-resizing [`Write::write_all_vectored`] implementation for slices.
+/// Exported for `Cursor<Box<[u8], A>>`'s implementation of [`Write`].
+#[inline]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn slice_write_all_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<()> {
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        if n < buf.len() {
+            return Err(io::Error::WRITE_ALL_EOF);
+        }
+    }
+    Ok(())
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Cursor<&mut [u8]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_array", since = "1.61.0")]
+impl<const N: usize> Write for Cursor<[u8; N]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all(pos, inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        let (pos, inner) = self.into_parts_mut();
+        slice_write_all_vectored(pos, inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> io::Seek for Cursor<T>
 where
@@ -328,3 +467,53 @@ where
         Ok(self.position())
     }
 }
+
+/// Trait used to allow indirect implementation of `Write` for `Cursor<Self>`.
+/// Since [`Cursor`] is not a foundational type, it is not possible to implement
+/// `Write` for `Cursor<T>` if `Write` is defined in `libcore` and `T` is in a
+/// downstream crate (e.g., `liballoc` or `libstd`).
+///
+/// Methods are identical in purpose and meaning to their `Write` namesakes.
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub trait WriteThroughCursor: Sized {
+    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize>;
+    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize>;
+    fn is_write_vectored(this: &Cursor<Self>) -> bool;
+    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()>;
+    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()>;
+    fn flush(this: &mut Cursor<Self>) -> io::Result<()>;
+}
+
+#[doc(hidden)]
+impl<W: WriteThroughCursor> Write for Cursor<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        WriteThroughCursor::write(self, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        WriteThroughCursor::write_vectored(self, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        WriteThroughCursor::is_write_vectored(self)
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        WriteThroughCursor::write_all(self, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        WriteThroughCursor::write_all_vectored(self, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        WriteThroughCursor::flush(self)
+    }
+}
diff --git a/library/core/src/io/error.rs b/library/core/src/io/error.rs
index 4214a5f87e3ef..eac7396bcfd83 100644
--- a/library/core/src/io/error.rs
+++ b/library/core/src/io/error.rs
@@ -79,7 +79,7 @@ pub type Result<T> = result::Result<T, Error>;
 ///
 // FIXME(#74481): Hard-links required to link from `core` to `std`
 /// [Read]: ../../std/io/trait.Read.html
-/// [Write]: ../../std/io/trait.Write.html
+/// [Write]: crate::io::Write
 /// [Seek]: crate::io::Seek
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_has_incoherent_inherent_impls]
@@ -853,7 +853,7 @@ pub enum ErrorKind {
     /// particular number of bytes but only a smaller number of bytes could be
     /// written.
     ///
-    /// [write]: ../../std/io/trait.Write.html#tymethod.write
+    /// [write]: crate::io::Write::write
     /// [`Ok(0)`]: Ok
     #[stable(feature = "rust1", since = "1.0.0")]
     WriteZero,
diff --git a/library/core/src/io/impls.rs b/library/core/src/io/impls.rs
index e8c716f060119..218bd7adc2a55 100644
--- a/library/core/src/io/impls.rs
+++ b/library/core/src/io/impls.rs
@@ -1,4 +1,5 @@
-use crate::io::{self, Seek, SeekFrom, SizeHint};
+use crate::io::{self, IoSlice, Seek, SeekFrom, SizeHint, Write};
+use crate::{cmp, fmt, mem};
 
 // =============================================================================
 // Forwarding implementations
@@ -17,6 +18,43 @@ impl<T> SizeHint for &mut T {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for &mut W {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<S: Seek + ?Sized> Seek for &mut S {
     #[inline]
@@ -61,3 +99,110 @@ impl SizeHint for &[u8] {
         Some(self.len())
     }
 }
+
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
+///
+/// If the number of bytes to be written exceeds the size of the slice, write operations will
+/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
+/// kind `ErrorKind::WriteZero`.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for &mut [u8] {
+    #[inline]
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(data.len(), self.len());
+        let (a, b) = mem::take(self).split_at_mut(amt);
+        a.copy_from_slice(&data[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            nwritten += self.write(buf)?;
+            if self.is_empty() {
+                break;
+            }
+        }
+
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
+        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[unstable(feature = "read_buf", issue = "78485")]
+impl<'a> io::Write for core::io::BorrowedCursor<'a, u8> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.capacity());
+        self.append(&buf[..amt]);
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            let n = self.write(buf)?;
+            nwritten += n;
+            if n < buf.len() {
+                break;
+            }
+        }
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/library/core/src/io/mod.rs b/library/core/src/io/mod.rs
index 1c27e42229bb7..0134540ae86c8 100644
--- a/library/core/src/io/mod.rs
+++ b/library/core/src/io/mod.rs
@@ -8,6 +8,7 @@ mod io_slice;
 mod seek;
 mod size_hint;
 mod util;
+mod write;
 
 #[unstable(feature = "core_io_borrowed_buf", issue = "117693")]
 pub use self::borrowed_buf::{BorrowedBuf, BorrowedCursor};
@@ -24,14 +25,20 @@ pub use self::{
     io_slice::{IoSlice, IoSliceMut},
     seek::{Seek, SeekFrom},
     util::{Chain, Empty, Repeat, Sink, Take, empty, repeat, sink},
+    write::Write,
 };
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
 pub use self::{
+    cursor::{
+        WriteThroughCursor, slice_write, slice_write_all, slice_write_all_vectored,
+        slice_write_vectored,
+    },
     error::{Custom, CustomOwner, OsFunctions},
     seek::stream_len_default,
     size_hint::SizeHint,
     util::{chain, take},
+    write::default_write_vectored,
 };
 
 /// Marks that a type `T` can have IO traits such as [`Seek`], [`Write`], etc. automatically
@@ -48,7 +55,7 @@ pub use self::{
 // FIXME(#74481): Hard-links required to link from `core` to `std`
 /// [file]: ../../std/fs/struct.File.html
 /// [arc]: ../../alloc/sync/struct.Arc.html
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Seek`]: crate::io::Seek
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
diff --git a/library/core/src/io/util.rs b/library/core/src/io/util.rs
index de37690436c80..b022d876eb8f5 100644
--- a/library/core/src/io/util.rs
+++ b/library/core/src/io/util.rs
@@ -1,10 +1,10 @@
-use crate::io::{ErrorKind, Result, Seek, SeekFrom, SizeHint};
+use crate::io::{self, ErrorKind, IoSlice, Result, Seek, SeekFrom, SizeHint, Write};
 use crate::{cmp, fmt};
 
 /// `Empty` ignores any data written via [`Write`], and will always be empty
 /// (returning zero bytes) when read via [`Read`].
 ///
-/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Write`]: crate::io::Write
 /// [`Read`]: ../../std/io/trait.Read.html
 ///
 /// This struct is generally created by calling [`empty()`]. Please
@@ -23,6 +23,84 @@ impl SizeHint for Empty {
     }
 }
 
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for &Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 #[stable(feature = "empty_seek", since = "1.51.0")]
 impl Seek for Empty {
     #[inline]
@@ -51,7 +129,7 @@ impl Seek for Empty {
 /// [`Ok(buf.len())`]: Ok
 /// [`Ok(0)`]: Ok
 ///
-/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+/// [`write`]: crate::io::Write::write
 /// [`read`]: ../../std/io/trait.Read.html#tymethod.read
 ///
 /// # Examples
@@ -142,12 +220,90 @@ impl fmt::Debug for Repeat {
 #[derive(Copy, Clone, Debug, Default)]
 pub struct Sink;
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "write_mt", since = "1.48.0")]
+impl Write for &Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 /// Creates an instance of a writer which will successfully consume all data.
 ///
 /// All calls to [`write`] on the returned instance will return [`Ok(buf.len())`]
 /// and the contents of the buffer will not be inspected.
 ///
-/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+/// [`write`]: crate::io::Write::write
 /// [`Ok(buf.len())`]: Ok
 ///
 /// # Examples
diff --git a/library/core/src/io/write.rs b/library/core/src/io/write.rs
new file mode 100644
index 0000000000000..cdddd380885f4
--- /dev/null
+++ b/library/core/src/io/write.rs
@@ -0,0 +1,417 @@
+use crate::fmt;
+use crate::io::{Error, IoSlice, Result};
+
+/// A trait for objects which are byte-oriented sinks.
+///
+/// Implementors of the `Write` trait are sometimes called 'writers'.
+///
+/// Writers are defined by two required methods, [`write`] and [`flush`]:
+///
+/// * The [`write`] method will attempt to write some data into the object,
+///   returning how many bytes were successfully written.
+///
+/// * The [`flush`] method is useful for adapters and explicit buffers
+///   themselves for ensuring that all buffered data has been pushed out to the
+///   'true sink'.
+///
+/// Writers are intended to be composable with one another. Many implementors
+/// throughout [`std::io`] take and provide types which implement the `Write`
+/// trait.
+///
+/// [`write`]: Write::write
+/// [`flush`]: Write::flush
+/// [`std::io`]: crate::io
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::fs::File;
+///
+/// fn main() -> std::io::Result<()> {
+///     let data = b"some bytes";
+///
+///     let mut pos = 0;
+///     let mut buffer = File::create("foo.txt")?;
+///
+///     while pos < data.len() {
+///         let bytes_written = buffer.write(&data[pos..])?;
+///         pos += bytes_written;
+///     }
+///     Ok(())
+/// }
+/// ```
+///
+/// The trait also provides convenience methods like [`write_all`], which calls
+/// `write` in a loop until its entire input has been written.
+///
+/// [`write_all`]: Write::write_all
+#[stable(feature = "rust1", since = "1.0.0")]
+#[doc(notable_trait)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "IoWrite")]
+pub trait Write {
+    /// Writes a buffer into this writer, returning how many bytes were written.
+    ///
+    /// This function will attempt to write the entire contents of `buf`, but
+    /// the entire write might not succeed, or the write may also generate an
+    /// error. Typically, a call to `write` represents one attempt to write to
+    /// any wrapped object.
+    ///
+    /// Calls to `write` are not guaranteed to block waiting for data to be
+    /// written, and a write which would otherwise block can be indicated through
+    /// an [`Err`] variant.
+    ///
+    /// If this method consumed `n > 0` bytes of `buf` it must return [`Ok(n)`].
+    /// If the return value is `Ok(n)` then `n` must satisfy `n <= buf.len()`.
+    /// A return value of `Ok(0)` typically means that the underlying object is
+    /// no longer able to accept bytes and will likely not be able to in the
+    /// future as well, or that the buffer provided is empty.
+    ///
+    /// # Errors
+    ///
+    /// Each call to `write` may generate an I/O error indicating that the
+    /// operation could not be completed. If an error is returned then no bytes
+    /// in the buffer were written to this writer.
+    ///
+    /// It is **not** considered an error if the entire buffer could not be
+    /// written to this writer.
+    ///
+    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
+    /// write operation should be retried if there is nothing else to do.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // Writes some prefix of the byte string, not necessarily all of it.
+    ///     buffer.write(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`Ok(n)`]: Ok
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+
+    /// Like [`write`], except that it writes from a slice of buffers.
+    ///
+    /// Data is copied from each buffer in order, with the final buffer
+    /// read from possibly being only partially consumed. This method must
+    /// behave as a call to [`write`] with the buffers concatenated would.
+    ///
+    /// The default implementation calls [`write`] with either the first nonempty
+    /// buffer provided, or an empty one if none exists.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::IoSlice;
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let data1 = [1; 8];
+    ///     let data2 = [15; 8];
+    ///     let io_slice1 = IoSlice::new(&data1);
+    ///     let io_slice2 = IoSlice::new(&data2);
+    ///
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // Writes some prefix of the byte string, not necessarily all of it.
+    ///     buffer.write_vectored(&[io_slice1, io_slice2])?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// [`write`]: Write::write
+    #[stable(feature = "iovec", since = "1.36.0")]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize> {
+        default_write_vectored(|b| self.write(b), bufs)
+    }
+
+    /// Determines if this `Write`r has an efficient [`write_vectored`]
+    /// implementation.
+    ///
+    /// If a `Write`r does not override the default [`write_vectored`]
+    /// implementation, code using it may want to avoid the method all together
+    /// and coalesce writes into a single buffer for higher performance.
+    ///
+    /// The default implementation returns `false`.
+    ///
+    /// [`write_vectored`]: Write::write_vectored
+    #[unstable(feature = "can_vector", issue = "69941")]
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+
+    /// Flushes this output stream, ensuring that all intermediately buffered
+    /// contents reach their destination.
+    ///
+    /// # Errors
+    ///
+    /// It is considered an error if not all bytes could be written due to
+    /// I/O errors or EOF being reached.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::io::BufWriter;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = BufWriter::new(File::create("foo.txt")?);
+    ///
+    ///     buffer.write_all(b"some bytes")?;
+    ///     buffer.flush()?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn flush(&mut self) -> Result<()>;
+
+    /// Attempts to write an entire buffer into this writer.
+    ///
+    /// This method will continuously call [`write`] until there is no more data
+    /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is
+    /// returned. This method will not return until the entire buffer has been
+    /// successfully written or such an error occurs. The first error that is
+    /// not of [`ErrorKind::Interrupted`] kind generated from this method will be
+    /// returned.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// If the buffer contains no data, this will never call [`write`].
+    ///
+    /// # Errors
+    ///
+    /// This function will return the first error of
+    /// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.
+    ///
+    /// [`write`]: Write::write
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     buffer.write_all(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
+        while !buf.is_empty() {
+            match self.write(buf) {
+                Ok(0) => {
+                    return Err(Error::WRITE_ALL_EOF);
+                }
+                Ok(n) => buf = &buf[n..],
+                Err(ref e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Attempts to write multiple buffers into this writer.
+    ///
+    /// This method will continuously call [`write_vectored`] until there is no
+    /// more data to be written or an error of non-[`ErrorKind::Interrupted`]
+    /// kind is returned. This method will not return until all buffers have
+    /// been successfully written or such an error occurs. The first error that
+    /// is not of [`ErrorKind::Interrupted`] kind generated from this method
+    /// will be returned.
+    ///
+    /// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+    ///
+    /// If the buffer contains no data, this will never call [`write_vectored`].
+    ///
+    /// # Notes
+    ///
+    /// Unlike [`write_vectored`], this takes a *mutable* reference to
+    /// a slice of [`IoSlice`]s, not an immutable one. That's because we need to
+    /// modify the slice to keep track of the bytes already written.
+    ///
+    /// Once this function returns, the contents of `bufs` are unspecified, as
+    /// this depends on how many calls to [`write_vectored`] were necessary. It is
+    /// best to understand this function as taking ownership of `bufs` and to
+    /// not use `bufs` afterwards. The underlying buffers, to which the
+    /// [`IoSlice`]s point (but not the [`IoSlice`]s themselves), are unchanged and
+    /// can be reused.
+    ///
+    /// [`write_vectored`]: Write::write_vectored
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(write_all_vectored)]
+    /// # fn main() -> std::io::Result<()> {
+    ///
+    /// use std::io::{Write, IoSlice};
+    ///
+    /// let mut writer = Vec::new();
+    /// let bufs = &mut [
+    ///     IoSlice::new(&[1]),
+    ///     IoSlice::new(&[2, 3]),
+    ///     IoSlice::new(&[4, 5, 6]),
+    /// ];
+    ///
+    /// writer.write_all_vectored(bufs)?;
+    /// // Note: the contents of `bufs` is now undefined, see the Notes section.
+    ///
+    /// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);
+    /// # Ok(()) }
+    /// ```
+    #[unstable(feature = "write_all_vectored", issue = "70436")]
+    fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
+        // Guarantee that bufs is empty if it contains no data,
+        // to avoid calling write_vectored if there is no data to be written.
+        IoSlice::advance_slices(&mut bufs, 0);
+        while !bufs.is_empty() {
+            match self.write_vectored(bufs) {
+                Ok(0) => {
+                    return Err(Error::WRITE_ALL_EOF);
+                }
+                Ok(n) => IoSlice::advance_slices(&mut bufs, n),
+                Err(ref e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Writes a formatted string into this writer, returning any error
+    /// encountered.
+    ///
+    /// This method is primarily used to interface with the
+    /// [`format_args!()`] macro, and it is rare that this should
+    /// explicitly be called. The [`write!()`] macro should be favored to
+    /// invoke this method instead.
+    ///
+    /// This function internally uses the [`write_all`] method on
+    /// this trait and hence will continuously write data so long as no errors
+    /// are received. This also means that partial writes are not indicated in
+    /// this signature.
+    ///
+    /// [`write_all`]: Write::write_all
+    ///
+    /// # Errors
+    ///
+    /// This function will return any I/O error reported while formatting.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::prelude::*;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     // this call
+    ///     write!(buffer, "{:.*}", 2, 1.234567)?;
+    ///     // turns into this:
+    ///     buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<()> {
+        if let Some(s) = args.as_statically_known_str() {
+            self.write_all(s.as_bytes())
+        } else {
+            default_write_fmt(self, args)
+        }
+    }
+
+    /// Creates a "by reference" adapter for this instance of `Write`.
+    ///
+    /// The returned adapter also implements `Write` and will simply borrow this
+    /// current writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::Write;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let mut buffer = File::create("foo.txt")?;
+    ///
+    ///     let reference = buffer.by_ref();
+    ///
+    ///     // we can use reference just like our original buffer
+    ///     reference.write_all(b"some bytes")?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn by_ref(&mut self) -> &mut Self
+    where
+        Self: Sized,
+    {
+        self
+    }
+}
+
+/// Default implementation of [`Write::write_vectored`], which is currently used
+/// in `libstd` for file system implementations of similar methods.
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+pub fn default_write_vectored<F>(write: F, bufs: &[IoSlice<'_>]) -> Result<usize>
+where
+    F: FnOnce(&[u8]) -> Result<usize>,
+{
+    let buf = bufs.iter().find(|b| !b.is_empty()).map_or(&[][..], |b| &**b);
+    write(buf)
+}
+
+fn default_write_fmt<W: Write + ?Sized>(this: &mut W, args: fmt::Arguments<'_>) -> Result<()> {
+    // Create a shim which translates a `Write` to a `fmt::Write` and saves off
+    // I/O errors, instead of discarding them.
+    struct Adapter<'a, T: ?Sized + 'a> {
+        inner: &'a mut T,
+        error: Result<()>,
+    }
+
+    impl<T: Write + ?Sized> fmt::Write for Adapter<'_, T> {
+        fn write_str(&mut self, s: &str) -> fmt::Result {
+            match self.inner.write_all(s.as_bytes()) {
+                Ok(()) => Ok(()),
+                Err(e) => {
+                    self.error = Err(e);
+                    Err(fmt::Error)
+                }
+            }
+        }
+    }
+
+    let mut output = Adapter { inner: this, error: Ok(()) };
+    match fmt::write(&mut output, args) {
+        Ok(()) => Ok(()),
+        Err(..) => {
+            // Check whether the error came from the underlying `Write`.
+            if output.error.is_err() {
+                output.error
+            } else {
+                // This shouldn't happen: the underlying stream did not error,
+                // but somehow the formatter still errored?
+                panic!(
+                    "a formatting trait implementation returned an error when the underlying stream did not"
+                );
+            }
+        }
+    }
+}
diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
index 5399789b4242f..e0b127bef8e2b 100644
--- a/library/std/src/io/cursor.rs
+++ b/library/std/src/io/cursor.rs
@@ -4,10 +4,8 @@ mod tests;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::io::Cursor;
 
-use crate::alloc::Allocator;
-use crate::cmp;
 use crate::io::prelude::*;
-use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
+use crate::io::{self, BorrowedCursor, IoSliceMut};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Read for Cursor<T>
@@ -101,414 +99,3 @@ where
         self.set_position(self.position() + amt as u64);
     }
 }
-
-/// Trait used to allow indirect implementation of `Write` for `Cursor<Self>`.
-/// Since [`Cursor`] is not a foundational type, it is not possible to implement
-/// `Write` for `Cursor<T>` if `Write` is defined in `libcore` and `T` is in a
-/// downstream crate (e.g., `liballoc` or `libstd`).
-///
-/// Methods are identical in purpose and meaning to their `Write` namesakes.
-trait WriteThroughCursor: Sized {
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize>;
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize>;
-    fn is_write_vectored(this: &Cursor<Self>) -> bool;
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()>;
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()>;
-    fn flush(this: &mut Cursor<Self>) -> io::Result<()>;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<W: WriteThroughCursor> Write for Cursor<W> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        WriteThroughCursor::write(self, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        WriteThroughCursor::write_vectored(self, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        WriteThroughCursor::is_write_vectored(self)
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        WriteThroughCursor::write_all(self, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        WriteThroughCursor::write_all_vectored(self, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        WriteThroughCursor::flush(self)
-    }
-}
-
-// Non-resizing write implementation
-#[inline]
-fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
-    let pos = cmp::min(*pos_mut, slice.len() as u64);
-    let amt = (&mut slice[(pos as usize)..]).write(buf)?;
-    *pos_mut += amt as u64;
-    Ok(amt)
-}
-
-#[inline]
-fn slice_write_vectored(
-    pos_mut: &mut u64,
-    slice: &mut [u8],
-    bufs: &[IoSlice<'_>],
-) -> io::Result<usize> {
-    let mut nwritten = 0;
-    for buf in bufs {
-        let n = slice_write(pos_mut, slice, buf)?;
-        nwritten += n;
-        if n < buf.len() {
-            break;
-        }
-    }
-    Ok(nwritten)
-}
-
-#[inline]
-fn slice_write_all(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<()> {
-    let n = slice_write(pos_mut, slice, buf)?;
-    if n < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-}
-
-#[inline]
-fn slice_write_all_vectored(
-    pos_mut: &mut u64,
-    slice: &mut [u8],
-    bufs: &[IoSlice<'_>],
-) -> io::Result<()> {
-    for buf in bufs {
-        let n = slice_write(pos_mut, slice, buf)?;
-        if n < buf.len() {
-            return Err(io::Error::WRITE_ALL_EOF);
-        }
-    }
-    Ok(())
-}
-
-/// Reserves the required space, and pads the vec with 0s if necessary.
-fn reserve_and_pad<A: Allocator>(
-    pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
-    buf_len: usize,
-) -> io::Result<usize> {
-    let pos: usize = (*pos_mut).try_into().map_err(|_| {
-        io::const_error!(
-            ErrorKind::InvalidInput,
-            "cursor position exceeds maximum possible vector length",
-        )
-    })?;
-
-    // For safety reasons, we don't want these numbers to overflow
-    // otherwise our allocation won't be enough
-    let desired_cap = pos.saturating_add(buf_len);
-    if desired_cap > vec.capacity() {
-        // We want our vec's total capacity
-        // to have room for (pos+buf_len) bytes. Reserve allocates
-        // based on additional elements from the length, so we need to
-        // reserve the difference
-        vec.reserve(desired_cap - vec.len());
-    }
-    // Pad if pos is above the current len.
-    if pos > vec.len() {
-        let diff = pos - vec.len();
-        // Unfortunately, `resize()` would suffice but the optimiser does not
-        // realise the `reserve` it does can be eliminated. So we do it manually
-        // to eliminate that extra branch
-        let spare = vec.spare_capacity_mut();
-        debug_assert!(spare.len() >= diff);
-        // Safety: we have allocated enough capacity for this.
-        // And we are only writing, not reading
-        unsafe {
-            spare.get_unchecked_mut(..diff).fill(core::mem::MaybeUninit::new(0));
-            vec.set_len(pos);
-        }
-    }
-
-    Ok(pos)
-}
-
-/// Writes the slice to the vec without allocating.
-///
-/// # Safety
-///
-/// `vec` must have `buf.len()` spare capacity.
-unsafe fn vec_write_all_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
-where
-    A: Allocator,
-{
-    debug_assert!(vec.capacity() >= pos + buf.len());
-    unsafe { vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()) };
-    pos + buf.len()
-}
-
-/// Resizing `write_all` implementation for [`Cursor`].
-///
-/// Cursor is allowed to have a pre-allocated and initialised
-/// vector body, but with a position of 0. This means the [`Write`]
-/// will overwrite the contents of the vec.
-///
-/// This also allows for the vec body to be empty, but with a position of N.
-/// This means that [`Write`] will pad the vec with 0 initially,
-/// before writing anything from that point
-fn vec_write_all<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
-where
-    A: Allocator,
-{
-    let buf_len = buf.len();
-    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
-
-    // Write the buf then progress the vec forward if necessary
-    // Safety: we have ensured that the capacity is available
-    // and that all bytes get written up to pos
-    unsafe {
-        pos = vec_write_all_unchecked(pos, vec, buf);
-        if pos > vec.len() {
-            vec.set_len(pos);
-        }
-    };
-
-    // Bump us forward
-    *pos_mut += buf_len as u64;
-    Ok(buf_len)
-}
-
-/// Resizing `write_all_vectored` implementation for [`Cursor`].
-///
-/// Cursor is allowed to have a pre-allocated and initialised
-/// vector body, but with a position of 0. This means the [`Write`]
-/// will overwrite the contents of the vec.
-///
-/// This also allows for the vec body to be empty, but with a position of N.
-/// This means that [`Write`] will pad the vec with 0 initially,
-/// before writing anything from that point
-fn vec_write_all_vectored<A>(
-    pos_mut: &mut u64,
-    vec: &mut Vec<u8, A>,
-    bufs: &[IoSlice<'_>],
-) -> io::Result<usize>
-where
-    A: Allocator,
-{
-    // For safety reasons, we don't want this sum to overflow ever.
-    // If this saturates, the reserve should panic to avoid any unsound writing.
-    let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
-    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
-
-    // Write the buf then progress the vec forward if necessary
-    // Safety: we have ensured that the capacity is available
-    // and that all bytes get written up to the last pos
-    unsafe {
-        for buf in bufs {
-            pos = vec_write_all_unchecked(pos, vec, buf);
-        }
-        if pos > vec.len() {
-            vec.set_len(pos);
-        }
-    }
-
-    // Bump us forward
-    *pos_mut += buf_len as u64;
-    Ok(buf_len)
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for Cursor<&mut [u8]> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
-impl<A> WriteThroughCursor for &mut Vec<u8, A>
-where
-    A: Allocator,
-{
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)
-    }
-
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)?;
-        Ok(())
-    }
-
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> WriteThroughCursor for Vec<u8, A>
-where
-    A: Allocator,
-{
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)
-    }
-
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all(pos, inner, buf)?;
-        Ok(())
-    }
-
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        vec_write_all_vectored(pos, inner, bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_box_slice", since = "1.5.0")]
-impl<A> WriteThroughCursor for Box<[u8], A>
-where
-    A: Allocator,
-{
-    #[inline]
-    fn write(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(this: &mut Cursor<Self>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(_this: &Cursor<Self>) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(this: &mut Cursor<Self>, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(this: &mut Cursor<Self>, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = this.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(_this: &mut Cursor<Self>) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "cursor_array", since = "1.61.0")]
-impl<const N: usize> Write for Cursor<[u8; N]> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all(pos, inner, buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        let (pos, inner) = self.into_parts_mut();
-        slice_write_all_vectored(pos, inner, bufs)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs
index 08bb34376b075..61f82828149aa 100644
--- a/library/std/src/io/impls.rs
+++ b/library/std/src/io/impls.rs
@@ -3,9 +3,9 @@ mod tests;
 
 use crate::alloc::Allocator;
 use crate::collections::VecDeque;
-use crate::io::{self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Write};
+use crate::io::{self, BorrowedCursor, BufRead, IoSliceMut, Read};
 use crate::sync::Arc;
-use crate::{cmp, fmt, mem, str};
+use crate::{cmp, str};
 
 // =============================================================================
 // Forwarding implementations
@@ -53,43 +53,6 @@ impl<R: Read + ?Sized> Read for &mut R {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<W: Write + ?Sized> Write for &mut W {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<B: BufRead + ?Sized> BufRead for &mut B {
     #[inline]
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -165,43 +128,6 @@ impl<R: Read + ?Sized> Read for Box<R> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<W: Write + ?Sized> Write for Box<W> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (**self).write_fmt(fmt)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<B: BufRead + ?Sized> BufRead for Box<B> {
     #[inline]
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
@@ -362,108 +288,6 @@ impl BufRead for &[u8] {
     }
 }
 
-/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
-/// its data.
-///
-/// Note that writing updates the slice to point to the yet unwritten part.
-/// The slice will be empty when it has been completely overwritten.
-///
-/// If the number of bytes to be written exceeds the size of the slice, write operations will
-/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
-/// kind `ErrorKind::WriteZero`.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for &mut [u8] {
-    #[inline]
-    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
-        let amt = cmp::min(data.len(), self.len());
-        let (a, b) = mem::take(self).split_at_mut(amt);
-        a.copy_from_slice(&data[..amt]);
-        *self = b;
-        Ok(amt)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let mut nwritten = 0;
-        for buf in bufs {
-            nwritten += self.write(buf)?;
-            if self.is_empty() {
-                break;
-            }
-        }
-
-        Ok(nwritten)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
-        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        for buf in bufs {
-            if self.write(buf)? < buf.len() {
-                return Err(io::Error::WRITE_ALL_EOF);
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-/// Write is implemented for `Vec<u8>` by appending to the vector.
-/// The vector will grow as needed.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Allocator> Write for Vec<u8, A> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let len = bufs.iter().map(|b| b.len()).sum();
-        self.reserve(len);
-        for buf in bufs {
-            self.extend_from_slice(buf);
-        }
-        Ok(len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend_from_slice(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        self.write_vectored(bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 /// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`.
 #[stable(feature = "vecdeque_read_write", since = "1.63.0")]
 impl<A: Allocator> Read for VecDeque<u8, A> {
@@ -573,96 +397,6 @@ impl<A: Allocator> BufRead for VecDeque<u8, A> {
     }
 }
 
-/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
-#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
-impl<A: Allocator> Write for VecDeque<u8, A> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.extend(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let len = bufs.iter().map(|b| b.len()).sum();
-        self.reserve(len);
-        for buf in bufs {
-            self.extend(&**buf);
-        }
-        Ok(len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.extend(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        self.write_vectored(bufs)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[unstable(feature = "read_buf", issue = "78485")]
-impl<'a> io::Write for core::io::BorrowedCursor<'a, u8> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let amt = cmp::min(buf.len(), self.capacity());
-        self.append(&buf[..amt]);
-        Ok(amt)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let mut nwritten = 0;
-        for buf in bufs {
-            let n = self.write(buf)?;
-            nwritten += n;
-            if n < buf.len() {
-                break;
-            }
-        }
-        Ok(nwritten)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        for buf in bufs {
-            if self.write(buf)? < buf.len() {
-                return Err(io::Error::WRITE_ALL_EOF);
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 #[stable(feature = "io_traits_arc", since = "1.73.0")]
 impl<R: Read + ?Sized> Read for Arc<R>
 where
@@ -709,44 +443,3 @@ where
         (&**self).read_buf_exact(cursor)
     }
 }
-#[stable(feature = "io_traits_arc", since = "1.73.0")]
-impl<W: Write + ?Sized> Write for Arc<W>
-where
-    for<'a> &'a W: Write,
-    W: crate::io::IoHandle,
-{
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (&**self).write(buf)
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        (&**self).write_vectored(bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        (&**self).is_write_vectored()
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        (&**self).flush()
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        (&**self).write_all(buf)
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        (&**self).write_all_vectored(bufs)
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        (&**self).write_fmt(fmt)
-    }
-}
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index 38c8120d66fc6..b1dbcf1f5bd46 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -306,11 +306,14 @@ pub use alloc_crate::io::RawOsError;
 pub use alloc_crate::io::SimpleMessage;
 #[unstable(feature = "io_const_error", issue = "133448")]
 pub use alloc_crate::io::const_error;
+#[allow(unused_imports, reason = "only used by certain platforms")]
+pub(crate) use alloc_crate::io::default_write_vectored;
 #[unstable(feature = "read_buf", issue = "78485")]
 pub use alloc_crate::io::{BorrowedBuf, BorrowedCursor};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc_crate::io::{
-    Chain, Empty, Error, ErrorKind, Repeat, Result, Seek, SeekFrom, Sink, Take, empty, repeat, sink,
+    Chain, Empty, Error, ErrorKind, Repeat, Result, Seek, SeekFrom, Sink, Take, Write, empty,
+    repeat, sink,
 };
 pub(crate) use alloc_crate::io::{IoHandle, stream_len_default};
 #[stable(feature = "iovec", since = "1.36.0")]
@@ -338,7 +341,7 @@ pub use self::{
     stdio::{Stderr, StderrLock, Stdin, StdinLock, Stdout, StdoutLock, stderr, stdin, stdout},
 };
 use crate::mem::MaybeUninit;
-use crate::{cmp, fmt, slice, str};
+use crate::{cmp, slice, str};
 
 mod buffered;
 pub(crate) mod copy;
@@ -549,14 +552,6 @@ where
     read(buf)
 }
 
-pub(crate) fn default_write_vectored<F>(write: F, bufs: &[IoSlice<'_>]) -> Result<usize>
-where
-    F: FnOnce(&[u8]) -> Result<usize>,
-{
-    let buf = bufs.iter().find(|b| !b.is_empty()).map_or(&[][..], |b| &**b);
-    write(buf)
-}
-
 pub(crate) fn default_read_exact<R: Read + ?Sized>(this: &mut R, mut buf: &mut [u8]) -> Result<()> {
     while !buf.is_empty() {
         match this.read(buf) {
@@ -600,47 +595,6 @@ pub(crate) fn default_read_buf_exact<R: Read + ?Sized>(
     Ok(())
 }
 
-pub(crate) fn default_write_fmt<W: Write + ?Sized>(
-    this: &mut W,
-    args: fmt::Arguments<'_>,
-) -> Result<()> {
-    // Create a shim which translates a `Write` to a `fmt::Write` and saves off
-    // I/O errors, instead of discarding them.
-    struct Adapter<'a, T: ?Sized + 'a> {
-        inner: &'a mut T,
-        error: Result<()>,
-    }
-
-    impl<T: Write + ?Sized> fmt::Write for Adapter<'_, T> {
-        fn write_str(&mut self, s: &str) -> fmt::Result {
-            match self.inner.write_all(s.as_bytes()) {
-                Ok(()) => Ok(()),
-                Err(e) => {
-                    self.error = Err(e);
-                    Err(fmt::Error)
-                }
-            }
-        }
-    }
-
-    let mut output = Adapter { inner: this, error: Ok(()) };
-    match fmt::write(&mut output, args) {
-        Ok(()) => Ok(()),
-        Err(..) => {
-            // Check whether the error came from the underlying `Write`.
-            if output.error.is_err() {
-                output.error
-            } else {
-                // This shouldn't happen: the underlying stream did not error,
-                // but somehow the formatter still errored?
-                panic!(
-                    "a formatting trait implementation returned an error when the underlying stream did not"
-                );
-            }
-        }
-    }
-}
-
 /// The `Read` trait allows for reading bytes from a source.
 ///
 /// Implementors of the `Read` trait are called 'readers'.
@@ -1403,365 +1357,6 @@ pub fn read_to_string<R: Read>(mut reader: R) -> Result<String> {
     Ok(buf)
 }
 
-/// A trait for objects which are byte-oriented sinks.
-///
-/// Implementors of the `Write` trait are sometimes called 'writers'.
-///
-/// Writers are defined by two required methods, [`write`] and [`flush`]:
-///
-/// * The [`write`] method will attempt to write some data into the object,
-///   returning how many bytes were successfully written.
-///
-/// * The [`flush`] method is useful for adapters and explicit buffers
-///   themselves for ensuring that all buffered data has been pushed out to the
-///   'true sink'.
-///
-/// Writers are intended to be composable with one another. Many implementors
-/// throughout [`std::io`] take and provide types which implement the `Write`
-/// trait.
-///
-/// [`write`]: Write::write
-/// [`flush`]: Write::flush
-/// [`std::io`]: self
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::io::prelude::*;
-/// use std::fs::File;
-///
-/// fn main() -> std::io::Result<()> {
-///     let data = b"some bytes";
-///
-///     let mut pos = 0;
-///     let mut buffer = File::create("foo.txt")?;
-///
-///     while pos < data.len() {
-///         let bytes_written = buffer.write(&data[pos..])?;
-///         pos += bytes_written;
-///     }
-///     Ok(())
-/// }
-/// ```
-///
-/// The trait also provides convenience methods like [`write_all`], which calls
-/// `write` in a loop until its entire input has been written.
-///
-/// [`write_all`]: Write::write_all
-#[stable(feature = "rust1", since = "1.0.0")]
-#[doc(notable_trait)]
-#[cfg_attr(not(test), rustc_diagnostic_item = "IoWrite")]
-pub trait Write {
-    /// Writes a buffer into this writer, returning how many bytes were written.
-    ///
-    /// This function will attempt to write the entire contents of `buf`, but
-    /// the entire write might not succeed, or the write may also generate an
-    /// error. Typically, a call to `write` represents one attempt to write to
-    /// any wrapped object.
-    ///
-    /// Calls to `write` are not guaranteed to block waiting for data to be
-    /// written, and a write which would otherwise block can be indicated through
-    /// an [`Err`] variant.
-    ///
-    /// If this method consumed `n > 0` bytes of `buf` it must return [`Ok(n)`].
-    /// If the return value is `Ok(n)` then `n` must satisfy `n <= buf.len()`.
-    /// A return value of `Ok(0)` typically means that the underlying object is
-    /// no longer able to accept bytes and will likely not be able to in the
-    /// future as well, or that the buffer provided is empty.
-    ///
-    /// # Errors
-    ///
-    /// Each call to `write` may generate an I/O error indicating that the
-    /// operation could not be completed. If an error is returned then no bytes
-    /// in the buffer were written to this writer.
-    ///
-    /// It is **not** considered an error if the entire buffer could not be
-    /// written to this writer.
-    ///
-    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
-    /// write operation should be retried if there is nothing else to do.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // Writes some prefix of the byte string, not necessarily all of it.
-    ///     buffer.write(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// [`Ok(n)`]: Ok
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write(&mut self, buf: &[u8]) -> Result<usize>;
-
-    /// Like [`write`], except that it writes from a slice of buffers.
-    ///
-    /// Data is copied from each buffer in order, with the final buffer
-    /// read from possibly being only partially consumed. This method must
-    /// behave as a call to [`write`] with the buffers concatenated would.
-    ///
-    /// The default implementation calls [`write`] with either the first nonempty
-    /// buffer provided, or an empty one if none exists.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::IoSlice;
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let data1 = [1; 8];
-    ///     let data2 = [15; 8];
-    ///     let io_slice1 = IoSlice::new(&data1);
-    ///     let io_slice2 = IoSlice::new(&data2);
-    ///
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // Writes some prefix of the byte string, not necessarily all of it.
-    ///     buffer.write_vectored(&[io_slice1, io_slice2])?;
-    ///     Ok(())
-    /// }
-    /// ```
-    ///
-    /// [`write`]: Write::write
-    #[stable(feature = "iovec", since = "1.36.0")]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize> {
-        default_write_vectored(|b| self.write(b), bufs)
-    }
-
-    /// Determines if this `Write`r has an efficient [`write_vectored`]
-    /// implementation.
-    ///
-    /// If a `Write`r does not override the default [`write_vectored`]
-    /// implementation, code using it may want to avoid the method all together
-    /// and coalesce writes into a single buffer for higher performance.
-    ///
-    /// The default implementation returns `false`.
-    ///
-    /// [`write_vectored`]: Write::write_vectored
-    #[unstable(feature = "can_vector", issue = "69941")]
-    fn is_write_vectored(&self) -> bool {
-        false
-    }
-
-    /// Flushes this output stream, ensuring that all intermediately buffered
-    /// contents reach their destination.
-    ///
-    /// # Errors
-    ///
-    /// It is considered an error if not all bytes could be written due to
-    /// I/O errors or EOF being reached.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::io::BufWriter;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = BufWriter::new(File::create("foo.txt")?);
-    ///
-    ///     buffer.write_all(b"some bytes")?;
-    ///     buffer.flush()?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn flush(&mut self) -> Result<()>;
-
-    /// Attempts to write an entire buffer into this writer.
-    ///
-    /// This method will continuously call [`write`] until there is no more data
-    /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is
-    /// returned. This method will not return until the entire buffer has been
-    /// successfully written or such an error occurs. The first error that is
-    /// not of [`ErrorKind::Interrupted`] kind generated from this method will be
-    /// returned.
-    ///
-    /// If the buffer contains no data, this will never call [`write`].
-    ///
-    /// # Errors
-    ///
-    /// This function will return the first error of
-    /// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.
-    ///
-    /// [`write`]: Write::write
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     buffer.write_all(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
-        while !buf.is_empty() {
-            match self.write(buf) {
-                Ok(0) => {
-                    return Err(Error::WRITE_ALL_EOF);
-                }
-                Ok(n) => buf = &buf[n..],
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Attempts to write multiple buffers into this writer.
-    ///
-    /// This method will continuously call [`write_vectored`] until there is no
-    /// more data to be written or an error of non-[`ErrorKind::Interrupted`]
-    /// kind is returned. This method will not return until all buffers have
-    /// been successfully written or such an error occurs. The first error that
-    /// is not of [`ErrorKind::Interrupted`] kind generated from this method
-    /// will be returned.
-    ///
-    /// If the buffer contains no data, this will never call [`write_vectored`].
-    ///
-    /// # Notes
-    ///
-    /// Unlike [`write_vectored`], this takes a *mutable* reference to
-    /// a slice of [`IoSlice`]s, not an immutable one. That's because we need to
-    /// modify the slice to keep track of the bytes already written.
-    ///
-    /// Once this function returns, the contents of `bufs` are unspecified, as
-    /// this depends on how many calls to [`write_vectored`] were necessary. It is
-    /// best to understand this function as taking ownership of `bufs` and to
-    /// not use `bufs` afterwards. The underlying buffers, to which the
-    /// [`IoSlice`]s point (but not the [`IoSlice`]s themselves), are unchanged and
-    /// can be reused.
-    ///
-    /// [`write_vectored`]: Write::write_vectored
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(write_all_vectored)]
-    /// # fn main() -> std::io::Result<()> {
-    ///
-    /// use std::io::{Write, IoSlice};
-    ///
-    /// let mut writer = Vec::new();
-    /// let bufs = &mut [
-    ///     IoSlice::new(&[1]),
-    ///     IoSlice::new(&[2, 3]),
-    ///     IoSlice::new(&[4, 5, 6]),
-    /// ];
-    ///
-    /// writer.write_all_vectored(bufs)?;
-    /// // Note: the contents of `bufs` is now undefined, see the Notes section.
-    ///
-    /// assert_eq!(writer, &[1, 2, 3, 4, 5, 6]);
-    /// # Ok(()) }
-    /// ```
-    #[unstable(feature = "write_all_vectored", issue = "70436")]
-    fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
-        // Guarantee that bufs is empty if it contains no data,
-        // to avoid calling write_vectored if there is no data to be written.
-        IoSlice::advance_slices(&mut bufs, 0);
-        while !bufs.is_empty() {
-            match self.write_vectored(bufs) {
-                Ok(0) => {
-                    return Err(Error::WRITE_ALL_EOF);
-                }
-                Ok(n) => IoSlice::advance_slices(&mut bufs, n),
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Writes a formatted string into this writer, returning any error
-    /// encountered.
-    ///
-    /// This method is primarily used to interface with the
-    /// [`format_args!()`] macro, and it is rare that this should
-    /// explicitly be called. The [`write!()`] macro should be favored to
-    /// invoke this method instead.
-    ///
-    /// This function internally uses the [`write_all`] method on
-    /// this trait and hence will continuously write data so long as no errors
-    /// are received. This also means that partial writes are not indicated in
-    /// this signature.
-    ///
-    /// [`write_all`]: Write::write_all
-    ///
-    /// # Errors
-    ///
-    /// This function will return any I/O error reported while formatting.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::prelude::*;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     // this call
-    ///     write!(buffer, "{:.*}", 2, 1.234567)?;
-    ///     // turns into this:
-    ///     buffer.write_fmt(format_args!("{:.*}", 2, 1.234567))?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<()> {
-        if let Some(s) = args.as_statically_known_str() {
-            self.write_all(s.as_bytes())
-        } else {
-            default_write_fmt(self, args)
-        }
-    }
-
-    /// Creates a "by reference" adapter for this instance of `Write`.
-    ///
-    /// The returned adapter also implements `Write` and will simply borrow this
-    /// current writer.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// use std::io::Write;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     let mut buffer = File::create("foo.txt")?;
-    ///
-    ///     let reference = buffer.by_ref();
-    ///
-    ///     // we can use reference just like our original buffer
-    ///     reference.write_all(b"some bytes")?;
-    ///     Ok(())
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn by_ref(&mut self) -> &mut Self
-    where
-        Self: Sized,
-    {
-        self
-    }
-}
-
 fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>) -> Result<usize> {
     let mut read = 0;
     loop {
diff --git a/library/std/src/io/util.rs b/library/std/src/io/util.rs
index ce2137f9567c7..ac3e0f84d1e80 100644
--- a/library/std/src/io/util.rs
+++ b/library/std/src/io/util.rs
@@ -3,10 +3,7 @@
 #[cfg(test)]
 mod tests;
 
-use crate::fmt;
-use crate::io::{
-    self, BorrowedCursor, BufRead, Empty, IoSlice, IoSliceMut, Read, Repeat, Sink, Write,
-};
+use crate::io::{self, BorrowedCursor, BufRead, Empty, IoSliceMut, Read, Repeat};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Read for Empty {
@@ -83,84 +80,6 @@ impl BufRead for Empty {
     }
 }
 
-#[stable(feature = "empty_write", since = "1.73.0")]
-impl Write for Empty {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "empty_write", since = "1.73.0")]
-impl Write for &Empty {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Read for Repeat {
     #[inline]
@@ -213,81 +132,3 @@ impl Read for Repeat {
         true
     }
 }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Write for Sink {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-#[stable(feature = "write_mt", since = "1.48.0")]
-impl Write for &Sink {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        let total_len = bufs.iter().map(|b| b.len()).sum();
-        Ok(total_len)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index db37df63c5763..7cf576ecd8803 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -322,6 +322,7 @@
 #![feature(borrowed_buf_init)]
 #![feature(bstr)]
 #![feature(bstr_internals)]
+#![feature(can_vector)]
 #![feature(cast_maybe_uninit)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
@@ -389,6 +390,7 @@
 #![feature(ub_checks)]
 #![feature(uint_carryless_mul)]
 #![feature(used_with_arg)]
+#![feature(write_all_vectored)]
 // tidy-alphabetical-end
 //
 // Library features (alloc):
diff --git a/tests/ui/suggestions/issue-105645.stderr b/tests/ui/suggestions/issue-105645.stderr
index 2b9a94d8e0ab2..2342c22cfa80a 100644
--- a/tests/ui/suggestions/issue-105645.stderr
+++ b/tests/ui/suggestions/issue-105645.stderr
@@ -7,7 +7,7 @@ LL |     foo(&mut bref);
    |     required by a bound introduced by this call
    |
 help: the trait `std::io::Write` is implemented for `&mut [u8]`
-  --> $SRC_DIR/std/src/io/impls.rs:LL:COL
+  --> $SRC_DIR/core/src/io/impls.rs:LL:COL
 note: required by a bound in `foo`
   --> $DIR/issue-105645.rs:8:21
    |