# Write in k210_hal::stdout - Rust
A trait for writing or formatting into Unicode-accepting buffers or streams.
Keywords: rust, rustlang, rust-lang, Write

# Trait k210_hal::stdout::Write

1.0.0 · source · [−]

    pub trait Write {
        fn write_str(&mut self, s: &str) -> Result<(), Error>;

        fn write_char(&mut self, c: char) -> Result<(), Error> { ... }
        fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error> { ... }
    }

Expand description

A trait for writing or formatting into Unicode-accepting buffers or streams.

This trait only accepts UTF-8–encoded data and is not flushable. If you only want to accept Unicode and you don’t need flushing, you should implement this trait; otherwise you should implement `std::io::Write`.

## Required methods

source

#### fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded.

This method can only succeed if the entire string slice was successfully written, and this method will not return until all data has been written or an error occurs.

##### Errors

This function will return an instance of `Error` on error.

##### Examples

    use std::fmt::{Error, Write};

    fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
        f.write_str(s)
    }

    let mut buf = String::new();
    writer(&mut buf, "hola").unwrap();
    assert_eq!(&buf, "hola");

## Provided methods

1.1.0 · source

#### fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a `char` into this writer, returning whether the write succeeded.

A single `char` may be encoded as more than one byte. This method can only succeed if the entire byte sequence was successfully written, and this method will not return until all data has been written or an error occurs.

##### Errors

This function will return an instance of `Error` on error.

##### Examples

    use std::fmt::{Error, Write};

    fn writer<W: Write>(f: &mut W, c: char) -> Result<(), Error> {
        f.write_char(c)
    }

    let mut buf = String::new();
    writer(&mut buf, 'a').unwrap();
    writer(&mut buf, 'b').unwrap();
    assert_eq!(&buf, "ab");

source

#### fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the `write!` macro with implementors of this trait.

This method should generally not be invoked manually, but rather through the `write!` macro itself.

##### Examples

    use std::fmt::{Error, Write};

    fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
        f.write_fmt(format_args!("{s}"))
    }

    let mut buf = String::new();
    writer(&mut buf, "world").unwrap();
    assert_eq!(&buf, "world");

## Implementations on Foreign Types

1.4.0 · source

### impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized,

source

#### fn write_str(&mut self, s: &str) -> Result<(), Error>

source

#### fn write_char(&mut self, c: char) -> Result<(), Error>

source

#### fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

1.2.0 · source

### impl<'_> Write for Formatter<'_>

source

#### fn write_str(&mut self, s: &str) -> Result<(), Error>

source

#### fn write_char(&mut self, c: char) -> Result<(), Error>

source

#### fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

## Implementors

source

### impl<'p, T> Write for Stdout<'p, T> where
T: Write<u8>,

source

### impl<Word, Error> Write for dyn Write<Word, Error = Error> + 'static where
Word: From<u8>,