Module std::io [−] [src]

Traits, helpers, and type definitions for core I/O functionality.

The std::io module contains a number of common things you'll need when doing input and output. The most core part of this module is the Read and Write traits, which provide the most general interface for reading and writing input and output.

Read and Write

Because they are traits, Read and Write are implemented by a number of other types, and you can implement them for your types too. As such, you'll see a few different types of I/O throughout the documentation in this module: Files, TcpStreams, and sometimes even Vec<T>s. For example, Read adds a read() method, which we can use on Files:

fn main() { use std::io; use std::io::prelude::*; use std::fs::File; fn foo() -> io::Result<()> { let mut f = try!(File::open("foo.txt")); let mut buffer = [0; 10]; // read up to 10 bytes try!(f.read(&mut buffer)); println!("The bytes: {:?}", buffer); Ok(()) } }

use std::io;
use std::io::prelude::*;
use std::fs::File;

let mut f = try!(File::open("foo.txt"));
let mut buffer = [0; 10];

// read up to 10 bytes
try!(f.read(&mut buffer));

println!("The bytes: {:?}", buffer);

Read and Write are so important, implementors of the two traits have a nickname: readers and writers. So you'll sometimes see 'a reader' instead of 'a type that implements the Read trait'. Much easier!

Seek and BufRead

Beyond that, there are two important traits that are provided: Seek and BufRead. Both of these build on top of a reader to control how the reading happens. Seek lets you control where the next byte is coming from:

fn main() { use std::io; use std::io::prelude::*; use std::io::SeekFrom; use std::fs::File; fn foo() -> io::Result<()> { let mut f = try!(File::open("foo.txt")); let mut buffer = [0; 10]; // skip to the last 10 bytes of the file try!(f.seek(SeekFrom::End(-10))); // read up to 10 bytes try!(f.read(&mut buffer)); println!("The bytes: {:?}", buffer); Ok(()) } }

use std::io;
use std::io::prelude::*;
use std::io::SeekFrom;
use std::fs::File;

let mut f = try!(File::open("foo.txt"));
let mut buffer = [0; 10];

// skip to the last 10 bytes of the file
try!(f.seek(SeekFrom::End(-10)));

// read up to 10 bytes
try!(f.read(&mut buffer));

println!("The bytes: {:?}", buffer);

BufRead uses an internal buffer to provide a number of other ways to read, but to show it off, we'll need to talk about buffers in general. Keep reading!

BufReader and BufWriter

Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be making near-constant calls to the operating system. To help with this, std::io comes with two structs, BufReader and BufWriter, which wrap readers and writers. The wrapper uses a buffer, reducing the number of calls and providing nicer methods for accessing exactly what you want.

For example, BufReader works with the BufRead trait to add extra methods to any reader:

fn main() { use std::io; use std::io::prelude::*; use std::io::BufReader; use std::fs::File; fn foo() -> io::Result<()> { let f = try!(File::open("foo.txt")); let mut reader = BufReader::new(f); let mut buffer = String::new(); // read a line into buffer try!(reader.read_line(&mut buffer)); println!("{}", buffer); Ok(()) } }

use std::io;
use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;

let f = try!(File::open("foo.txt"));
let mut reader = BufReader::new(f);
let mut buffer = String::new();

// read a line into buffer
try!(reader.read_line(&mut buffer));

println!("{}", buffer);

BufWriter doesn't add any new ways of writing; it just buffers every call to write():

fn main() { use std::io; use std::io::prelude::*; use std::io::BufWriter; use std::fs::File; fn foo() -> io::Result<()> { let f = try!(File::create("foo.txt")); { let mut writer = BufWriter::new(f); // write a byte to the buffer try!(writer.write(&[42])); } // the buffer is flushed once writer goes out of scope Ok(()) } }

use std::io;
use std::io::prelude::*;
use std::io::BufWriter;
use std::fs::File;

let f = try!(File::create("foo.txt"));
{
    let mut writer = BufWriter::new(f);

    // write a byte to the buffer
    try!(writer.write(&[42]));

} // the buffer is flushed once writer goes out of scope

Standard input and output

A very common source of input is standard input:

fn main() { use std::io; fn foo() -> io::Result<()> { let mut input = String::new(); try!(io::stdin().read_line(&mut input)); println!("You typed: {}", input.trim()); Ok(()) } }

use std::io;

let mut input = String::new();

try!(io::stdin().read_line(&mut input));

println!("You typed: {}", input.trim());

And a very common source of output is standard output:

fn main() { use std::io; use std::io::prelude::*; fn foo() -> io::Result<()> { try!(io::stdout().write(&[42])); Ok(()) } }

use std::io;
use std::io::prelude::*;

try!(io::stdout().write(&[42]));

Of course, using io::stdout() directly is less common than something like println!.

Iterator types

A large number of the structures provided by std::io are for various ways of iterating over I/O. For example, Lines is used to split over lines:

fn main() { use std::io; use std::io::prelude::*; use std::io::BufReader; use std::fs::File; fn foo() -> io::Result<()> { let f = try!(File::open("foo.txt")); let mut reader = BufReader::new(f); for line in reader.lines() { let line = try!(line); println!("{}", line); } Ok(()) } }

use std::io;
use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;

let f = try!(File::open("foo.txt"));
let mut reader = BufReader::new(f);

for line in reader.lines() {
    let line = try!(line);
    println!("{}", line);
}

Functions

There are a number of functions that offer access to various features. For example, we can use three of these functions to copy everything from standard input to standard output:

fn main() { use std::io; fn foo() -> io::Result<()> { try!(io::copy(&mut io::stdin(), &mut io::stdout())); Ok(()) } }

use std::io;

try!(io::copy(&mut io::stdin(), &mut io::stdout()));

io::Result

Last, but certainly not least, is io::Result. This type is used as the return type of many std::io functions that can cause an error, and can be returned from your own functions as well. Many of the examples in this module use the try! macro:

fn main() { use std::io; fn read_input() -> io::Result<()> { let mut input = String::new(); try!(io::stdin().read_line(&mut input)); println!("You typed: {}", input.trim()); Ok(()) } }

use std::io;

fn read_input() -> io::Result<()> {
    let mut input = String::new();

    try!(io::stdin().read_line(&mut input));

    println!("You typed: {}", input.trim());

    Ok(())
}

The return type of read_input(), io::Result<()>, is a very common type for functions which don't have a 'real' return value, but do want to return errors if they happen. In this case, the only purpose of this function is to read the line and print it, so we use ().

Platform-specific behavior

Many I/O functions throughout the standard library are documented to indicate what various library or syscalls they are delegated to. This is done to help applications both understand what's happening under the hood as well as investigate any possibly unclear semantics. Note, however, that this is informative, not a binding contract. The implementation of many of these functions are subject to change over time and may call fewer or more syscalls/library functions.

Modules

prelude

The I/O Prelude

Structs

BufReader	The `BufReader` struct adds buffering to any reader.
BufWriter	Wraps a writer and buffers its output.
Bytes	An iterator over `u8` values of a reader.
Chain	Adaptor to chain together two readers.
Cursor	A `Cursor` wraps another type and provides it with a `Seek` implementation.
Empty	A reader which is always at EOF.
Error	The error type for I/O operations of the `Read`, `Write`, `Seek`, and associated traits.
IntoInnerError	An error returned by `into_inner` which combines an error that happened while writing out the buffer, and the buffered writer object which may be used to recover from the condition.
LineWriter	Wraps a writer and buffers output to it, flushing whenever a newline (`0x0a`, `'\n'`) is detected.
Lines	An iterator over the lines of an instance of `BufRead`.
Repeat	A reader which yields one byte over and over and over and over and over and...
Sink	A writer which will move data into the void.
Split	An iterator over the contents of an instance of `BufRead` split on a particular byte.
Stderr	A handle to the standard error stream of a process.
StderrLock	A locked reference to the `Stderr` handle.
Stdin	A handle to the standard input stream of a process.
StdinLock	A locked reference to the `Stdin` handle.
Stdout	A handle to the global standard output stream of the current process.
StdoutLock	A locked reference to the `Stdout` handle.
Take	Reader adaptor which limits the bytes read from an underlying reader.
Chars	[Unstable] An iterator over the `char`s of a reader.

Enums

ErrorKind	A list specifying general categories of I/O error.
SeekFrom	Enumeration of possible methods to seek within an I/O object.
CharsError	[Unstable] An enumeration of possible errors that can be generated from the `Chars` adapter.

Traits

BufRead	A `BufRead` is a type of `Read`er which has an internal buffer, allowing it to perform extra ways of reading.
Read	The `Read` trait allows for reading bytes from a source.
Seek	The `Seek` trait provides a cursor which can be moved within a stream of bytes.
Write	A trait for objects which are byte-oriented sinks.

Functions

copy	Copies the entire contents of a reader into a writer.
empty	Constructs a new handle to an empty reader.
repeat	Creates an instance of a reader that infinitely repeats one byte.
sink	Creates an instance of a writer which will successfully consume all data.
stderr	Constructs a new handle to the standard error of the current process.
stdin	Constructs a new handle to the standard input of the current process.
stdout	Constructs a new handle to the standard output of the current process.

Type Definitions

Result

A specialized Result type for I/O operations.