Rust by Example

let s = String::from_utf8_lossy(&output.stderr);

print!("rustc failed and stderr was:\n{}", s);

}

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

(You are encouraged to try the previous example with an incorrect flag passed to rustc)

Pipes

The std::Child struct represents a running child process, and exposes the stdin, stdout and stderr handles for interaction with the underlying process via pipes.

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

use std::process::{Command, Stdio};

static PANGRAM: &'static str =

"the quick brown fox jumped over the lazy dog\n";

fn main() {

// Spawn the `wc` command

let process = match Command::new("wc")

.stdin(Stdio::piped())

.stdout(Stdio::piped())

.spawn() {

Err(why) => panic!("couldn't spawn wc: {}", why),

Ok(process) => process,

};

// Write a string to the `stdin` of `wc`.

//

// `stdin` has type `Option`, but since we know this instance

// must have one, we can directly `unwrap` it.

match process.stdin.unwrap().write_all(PANGRAM.as_bytes()) {

Err(why) => panic!("couldn't write to wc stdin: {}", why),

Ok(_) => println!("sent pangram to wc"),

}

// Because `stdin` does not live after the above calls, it is `drop`ed,

// and the pipe is closed.

//

// This is very important, otherwise `wc` wouldn't start processing the

// input we just sent.

// The `stdout` field also has type `Option` so must be unwrapped.

let mut s = String::new();

match process.stdout.unwrap().read_to_string(&mut s) {

Err(why) => panic!("couldn't read wc stdout: {}", why),

Ok(_) => print!("wc responded with:\n{}", s),

}

}

Wait

If you'd like to wait for a process::Child to finish, you must call Child::wait, which will return a process::ExitStatus.

use std::process::Command;

fn main() {

let mut child = Command::new("sleep").arg("5").spawn().unwrap();

let _result = child.wait().unwrap();

println!("reached end of main");

}

$ rustc wait.rs && ./wait

# `wait` keeps running for 5 seconds until the `sleep 5` command finishes

reached end of main

Filesystem Operations

The std::fs module contains several functions that deal with the filesystem.

use std::fs;

use std::fs::{File, OpenOptions};

use std::io;

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

use std::os::unix;

use std::path::Path;

// A simple implementation of `% cat path`

fn cat(path: &Path) -> io::Result {

let mut f = File::open(path)?;

let mut s = String::new();