std::fmt::Arguments - Rust
Description: API documentation for the Rust `Arguments` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, Arguments

# 1.0.0[−][src]Struct std::fmt::Arguments

    pub struct Arguments<'a> { /* fields omitted */ }

This structure represents a safely precompiled version of a format string and its arguments. This cannot be generated at runtime because it cannot safely be done, so no constructors are given and the fields are private to prevent modification.

The `format_args!` macro will safely create an instance of this structure. The macro validates the format string at compile-time so usage of the `write()` and `format()` functions can be safely performed.

You can use the `Arguments<'a>` that `format_args!` returns in `Debug` and `Display` contexts as seen below. The example also shows that `Debug` and `Display` format to the same thing: the interpolated format string in `format_args!`.

    let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
    let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
    assert_eq!("1 foo 2", display);
    assert_eq!(display, debug);

Run

## Implementations

### `impl<'a> Arguments<'a>`[src]

#### `pub fn as_str(&self) -> Option<&'static str>`[src]

🔬 This is a nightly-only experimental API. (`fmt_as_str` #74442)

Get the formatted string, if it has no arguments to be formatted.

This can be used to avoid allocations in the most trivial case.

# Examples

    #![feature(fmt_as_str)]

    use core::fmt::Arguments;

    fn write_str(_: &str) { /* ... */ }

    fn write_fmt(args: &Arguments) {
        if let Some(s) = args.as_str() {
            write_str(s)
        } else {
            write_str(&args.to_string());
        }
    }

Run

    #![feature(fmt_as_str)]

    assert_eq!(format_args!("hello").as_str(), Some("hello"));
    assert_eq!(format_args!("").as_str(), Some(""));
    assert_eq!(format_args!("{}", 1).as_str(), None);

Run

## Trait Implementations

### `impl<'a> Clone for Arguments<'a>`[src]

#### `fn clone(&self) -> Arguments<'a>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`[src]

Performs copy-assignment from `source`. Read more

### `impl<'a> Copy for Arguments<'a>`[src]

### `impl<'_> Debug for Arguments<'_>`[src]

#### `fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

### `impl<'_> Display for Arguments<'_>`[src]

#### `fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl<'a> !RefUnwindSafe for Arguments<'a>`

### `impl<'a> !Send for Arguments<'a>`

### `impl<'a> !Sync for Arguments<'a>`

### `impl<'a> Unpin for Arguments<'a>`

### `impl<'a> !UnwindSafe for Arguments<'a>`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized, '_> Read for &'_ mut Rimpl<W: Write + ?Sized, '_> Write for &'_ mut W`
`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized, '_> Read for &'_ mut Rimpl<W: Write + ?Sized, '_> Write for &'_ mut W`
`[src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `default fn to_string(&self) -> String`[src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.