Трейт AsyncWriteExt

Записывает буфер в это средство записи и возвращает количество записанных байтов.

Эквивалентно:

async fn write(&mut self, buf: &[u8]) -> io::Result<usize>;

Эта функция попытается записать всё содержимое buf, однако запись может быть выполнена не полностью или завершиться ошибкой. Вызов write представляет собой не более чем одну попытку записи в любой обёрнутый объект.

Возвращаемое значение

Если возвращаемое значение — Ok(n), то должно быть гарантировано, что n <= buf.len(). Возвращаемое значение 0 обычно означает, что нижележащий объект больше не может принимать байты и, вероятно, не сможет делать это и в будущем, либо что переданный буфер пуст.

Ошибки

Каждый вызов write может привести к ошибке ввода-вывода, указывающей на то, что операцию не удалось завершить. Если возвращена ошибка, ни один байт из буфера не был записан в это средство записи.

Если буфер не удалось записать в это средство записи полностью, это не считается ошибкой.

Безопасность при отмене

Этот метод безопасен при отмене. Если он используется как ветвь в tokio::select! и первой завершается другая ветвь, гарантируется, что в этот AsyncWrite не были записаны данные.

Примеры

use tokio::io::{self, AsyncWriteExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("foo.txt").await?;

    // Writes some prefix of the byte string, not necessarily all of it.
    file.write(b"some bytes").await?;
    file.flush().await?;
    Ok(())
}

Подобен write, но записывает данные из среза буферов.

Эквивалентно:

async fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize>;

Дополнительные сведения см. в AsyncWrite::poll_write_vectored.

Безопасность при отмене

Этот метод безопасен при отмене. Если он используется как ветвь в tokio::select! и первой завершается другая ветвь, гарантируется, что в этот AsyncWrite не были записаны данные.

Примеры

use tokio::io::{self, AsyncWriteExt};
use tokio::fs::File;
use std::io::IoSlice;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("foo.txt").await?;

    let bufs: &[_] = &[
        IoSlice::new(b"hello"),
        IoSlice::new(b" "),
        IoSlice::new(b"world"),
    ];

    file.write_vectored(&bufs).await?;
    file.flush().await?;

    Ok(())
}

Записывает буфер в это средство записи, сдвигая внутренний курсор буфера.

Эквивалентно:

async fn write_buf<B: Buf>(&mut self, buf: &mut B) -> io::Result<usize>;

Эта функция попытается записать всё содержимое buf, однако запись может быть выполнена не полностью или завершиться ошибкой. После завершения операции внутренний курсор буфера сдвигается на количество записанных байтов. Последующий вызов write_buf с использованием того же значения buf продолжит запись с места, на котором завершился первый вызов write_buf. Вызов write_buf представляет собой не более чем одну попытку записи в любой обёрнутый объект.

Возвращаемое значение

Если возвращаемое значение — Ok(n), то должно быть гарантировано, что n <= buf.len(). Возвращаемое значение 0 обычно означает, что нижележащий объект больше не может принимать байты и, вероятно, не сможет делать это и в будущем, либо что переданный буфер пуст.

Ошибки

Каждый вызов write может привести к ошибке ввода-вывода, указывающей на то, что операцию не удалось завершить. Если возвращена ошибка, ни один байт из буфера не был записан в это средство записи.

Если буфер не удалось записать в это средство записи полностью, это не считается ошибкой.

Безопасность при отмене

Этот метод безопасен при отмене. Если он используется как ветвь в tokio::select! и первой завершается другая ветвь, гарантируется, что в этот AsyncWrite не были записаны данные.

Примеры

File реализует AsyncWrite, а Cursor<&[u8]> реализует Buf:

use tokio::io::{self, AsyncWriteExt};
use tokio::fs::File;

use bytes::Buf;
use std::io::Cursor;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("foo.txt").await?;
    let mut buffer = Cursor::new(b"data to write");

    // Loop until the entire contents of the buffer are written to
    // the file.
    while buffer.has_remaining() {
        // Writes some prefix of the byte string, not necessarily
        // all of it.
        file.write_buf(&mut buffer).await?;
    }
    file.flush().await?;

    Ok(())
}

Пытается записать весь буфер в этот объект записи.

Эквивалентно:

async fn write_all_buf(&mut self, buf: impl Buf) -> Result<(), io::Error> {
    while buf.has_remaining() {
        self.write_buf(&mut buf).await?;
    }
    Ok(())
}

Этот метод будет непрерывно вызывать write, пока buf.has_remaining() не вернёт false. Метод не вернёт управление, пока весь буфер не будет успешно записан или не произойдёт ошибка. Будет возвращена первая возникшая ошибка.

Буфер смещается после успешной записи каждого фрагмента. В случае ошибки src.chunk() вернёт фрагмент, который не удалось записать.

Безопасность при отмене

Если write_all_buf используется как ветвь в tokio::select!, а первой завершается другая ветвь, данные в предоставленном буфере могли быть записаны частично. Однако гарантируется, что предоставленный буфер был смещён на количество частично записанных байтов.

Примеры

File реализует AsyncWrite, а Cursor<&[u8]> реализует Buf:

use tokio::io::{self, AsyncWriteExt};
use tokio::fs::File;

use std::io::Cursor;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("foo.txt").await?;
    let mut buffer = Cursor::new(b"data to write");

    file.write_all_buf(&mut buffer).await?;
    file.flush().await?;
    Ok(())
}

Пытается записать весь буфер в этот объект записи.

Эквивалентно:

async fn write_all(&mut self, buf: &[u8]) -> io::Result<()>;

Этот метод будет непрерывно вызывать write, пока не останется данных для записи. Метод не вернёт управление, пока весь буфер не будет успешно записан или не произойдёт ошибка. Будет возвращена первая ошибка, возникшая при выполнении этого метода.

Безопасность при отмене

Этот метод не является безопасным при отмене. Если он используется как ветвь в tokio::select!, а первой завершается другая ветвь, предоставленный буфер мог быть записан частично, но последующие вызовы write_all начнут запись с начала буфера.

Ошибки

Эта функция вернёт первую ошибку, возвращённую методом write.

Примеры

use tokio::io::{self, AsyncWriteExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("foo.txt").await?;

    file.write_all(b"some bytes").await?;
    file.flush().await?;
    Ok(())
}

Записывает беззнаковое 8-битное целое число в базовый объект записи.

Эквивалентно:

async fn write_u8(&mut self, n: u8) -> io::Result<()>;

Для сокращения количества системных вызовов рекомендуется использовать буферизованный объект записи.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 8-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u8(2).await?;
writer.write_u8(5).await?;

assert_eq!(writer, b"\x02\x05");
Ok(())

Записывает знаковое 8-битное целое число в базовый объект записи.

Эквивалентно:

async fn write_i8(&mut self, n: i8) -> io::Result<()>;

Для сокращения количества системных вызовов рекомендуется использовать буферизованный объект записи.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 8-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i8(-2).await?;
writer.write_i8(126).await?;

assert_eq!(writer, b"\xFE\x7E");
Ok(())

Записывает беззнаковое 16-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_u16(&mut self, n: u16) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 16-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u16(517).await?;
writer.write_u16(768).await?;

assert_eq!(writer, b"\x02\x05\x03\x00");
Ok(())

Записывает знаковое 16-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_i16(&mut self, n: i16) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 16-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i16(193).await?;
writer.write_i16(-132).await?;

assert_eq!(writer, b"\x00\xc1\xff\x7c");
Ok(())

Записывает беззнаковое 32-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_u32(&mut self, n: u32) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 32-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u32(267).await?;
writer.write_u32(1205419366).await?;

assert_eq!(writer, b"\x00\x00\x01\x0b\x47\xd9\x3d\x66");
Ok(())

Записывает знаковое 32-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_i32(&mut self, n: i32) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 32-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i32(267).await?;
writer.write_i32(1205419366).await?;

assert_eq!(writer, b"\x00\x00\x01\x0b\x47\xd9\x3d\x66");
Ok(())

Записывает беззнаковое 64-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_u64(&mut self, n: u64) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 64-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u64(918733457491587).await?;
writer.write_u64(143).await?;

assert_eq!(writer, b"\x00\x03\x43\x95\x4d\x60\x86\x83\x00\x00\x00\x00\x00\x00\x00\x8f");
Ok(())

Записывает знаковое 64-битное целое число в порядке от старшего байта к младшему в нижележащий объект записи.

Эквивалентно:

async fn write_i64(&mut self, n: i64) -> io::Result<()>;

Рекомендуется использовать буферизованный объект записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 64-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i64(i64::MIN).await?;
writer.write_i64(i64::MAX).await?;

assert_eq!(writer, b"\x80\x00\x00\x00\x00\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff");
Ok(())

Записывает беззнаковое 128-битное целое число в порядке от старшего байта к младшему в базовый поток вывода.

Эквивалентно:

async fn write_u128(&mut self, n: u128) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 128-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u128(16947640962301618749969007319746179).await?;

assert_eq!(writer, vec![
    0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
    0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
]);
Ok(())

Записывает знаковое 128-битное целое число в порядке от старшего байта к младшему в базовый поток вывода.

Эквивалентно:

async fn write_i128(&mut self, n: i128) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 128-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i128(i128::MIN).await?;

assert_eq!(writer, vec![
    0x80, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0
]);
Ok(())

Записывает 32-битное число с плавающей точкой в порядке от старшего байта к младшему в базовый поток вывода.

Эквивалентно:

async fn write_f32(&mut self, n: f32) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись 32-битного числа с плавающей точкой в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_f32(f32::MIN).await?;

assert_eq!(writer, vec![0xff, 0x7f, 0xff, 0xff]);
Ok(())

Записывает 64-битное число с плавающей точкой в порядке от старшего байта к младшему в базовый поток вывода.

Эквивалентно:

async fn write_f64(&mut self, n: f64) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись 64-битного числа с плавающей точкой в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_f64(f64::MIN).await?;

assert_eq!(writer, vec![
    0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
]);
Ok(())

Записывает беззнаковое 16-битное целое число в порядке от младшего байта к старшему в базовый поток вывода.

Эквивалентно:

async fn write_u16_le(&mut self, n: u16) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 16-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u16_le(517).await?;
writer.write_u16_le(768).await?;

assert_eq!(writer, b"\x05\x02\x00\x03");
Ok(())

Записывает знаковое 16-битное целое число в порядке от младшего байта к старшему в базовый поток вывода.

Эквивалентно:

async fn write_i16_le(&mut self, n: i16) -> io::Result<()>;

Для предотвращения чрезмерного количества системных вызовов рекомендуется использовать буферизованный поток вывода.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 16-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i16_le(193).await?;
writer.write_i16_le(-132).await?;

assert_eq!(writer, b"\xc1\x00\x7c\xff");
Ok(())

Записывает беззнаковое 32-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_u32_le(&mut self, n: u32) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 32-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u32_le(267).await?;
writer.write_u32_le(1205419366).await?;

assert_eq!(writer, b"\x0b\x01\x00\x00\x66\x3d\xd9\x47");
Ok(())

Записывает знаковое 32-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_i32_le(&mut self, n: i32) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 32-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i32_le(267).await?;
writer.write_i32_le(1205419366).await?;

assert_eq!(writer, b"\x0b\x01\x00\x00\x66\x3d\xd9\x47");
Ok(())

Записывает беззнаковое 64-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_u64_le(&mut self, n: u64) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 64-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u64_le(918733457491587).await?;
writer.write_u64_le(143).await?;

assert_eq!(writer, b"\x83\x86\x60\x4d\x95\x43\x03\x00\x8f\x00\x00\x00\x00\x00\x00\x00");
Ok(())

Записывает знаковое 64-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_i64_le(&mut self, n: i64) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 64-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i64_le(i64::MIN).await?;
writer.write_i64_le(i64::MAX).await?;

assert_eq!(writer, b"\x00\x00\x00\x00\x00\x00\x00\x80\xff\xff\xff\xff\xff\xff\xff\x7f");
Ok(())

Записывает беззнаковое 128-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_u128_le(&mut self, n: u128) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись беззнаковых 128-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_u128_le(16947640962301618749969007319746179).await?;

assert_eq!(writer, vec![
    0x83, 0x86, 0x60, 0x4d, 0x95, 0x43, 0x03, 0x00,
    0x83, 0x86, 0x60, 0x4d, 0x95, 0x43, 0x03, 0x00,
]);
Ok(())

Записывает знаковое 128-битное целое число в порядке от младшего байта к старшему в базовое средство записи.

Эквивалентно:

async fn write_i128_le(&mut self, n: i128) -> io::Result<()>;

Рекомендуется использовать буферизованное средство записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись знаковых 128-битных целых чисел в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_i128_le(i128::MIN).await?;

assert_eq!(writer, vec![
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0x80
]);
Ok(())

Записывает 32-битное число с плавающей точкой в порядке байтов от младшего к старшему в нижележащий поток записи.

Эквивалентно:

async fn write_f32_le(&mut self, n: f32) -> io::Result<()>;

Рекомендуется использовать буферизованный поток записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись 32-битного числа с плавающей точкой в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_f32_le(f32::MIN).await?;

assert_eq!(writer, vec![0xff, 0xff, 0x7f, 0xff]);
Ok(())

Записывает 64-битное число с плавающей точкой в порядке байтов от младшего к старшему в нижележащий поток записи.

Эквивалентно:

async fn write_f64_le(&mut self, n: f64) -> io::Result<()>;

Рекомендуется использовать буферизованный поток записи, чтобы избежать чрезмерного количества системных вызовов.

Ошибки

Этот метод возвращает те же ошибки, что и AsyncWriteExt::write_all.

Примеры

Запись 64-битного числа с плавающей точкой в AsyncWrite:

use tokio::io::{self, AsyncWriteExt};

let mut writer = Vec::new();

writer.write_f64_le(f64::MIN).await?;

assert_eq!(writer, vec![
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff
]);
Ok(())

Сбрасывает этот поток вывода, обеспечивая передачу всего содержимого, временно находящегося в буфере, в место назначения.

Эквивалентно:

async fn flush(&mut self) -> io::Result<()>;

Ошибки

Возникает ошибка, если не удалось записать все байты из-за ошибок ввода-вывода или достижения конца файла (EOF).

Безопасность отмены

Этот метод безопасен при отмене.

Если flush используется в качестве ветви в tokio::select! и первой завершается другая ветвь, буферизованные данные в этом AsyncWrite могли быть сброшены лишь частично. Однако гарантируется, что буфер сдвинут на количество частично сброшенных байтов.

Примеры

use tokio::io::{self, BufWriter, AsyncWriteExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let f = File::create("foo.txt").await?;
    let mut buffer = BufWriter::new(f);

    buffer.write_all(b"some bytes").await?;
    buffer.flush().await?;
    Ok(())
}

Завершает работу потока вывода, обеспечивая возможность корректно удалить значение.

Эквивалентно:

async fn shutdown(&mut self) -> io::Result<()>;

Подобно flush, всё содержимое, временно находящееся в буфере, записывается в нижележащий поток. После завершения операции вызывающий код больше не должен пытаться записывать данные в поток. Например, реализация TcpStream выполнит системный вызов shutdown(Write).

Примеры

use tokio::io::{self, BufWriter, AsyncWriteExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let f = File::create("foo.txt").await?;
    let mut buffer = BufWriter::new(f);

    buffer.write_all(b"some bytes").await?;
    buffer.shutdown().await?;
    Ok(())
}