Rust by Example

Want a string that's not UTF-8? (Remember, str and String must be valid UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings to the rescue!

use std::str;

fn main() {

// Note that this is not actually a `&str`

let bytestring: &[u8; 21] = b"this is a byte string";

// Byte arrays don't have the `Display` trait, so printing them is a bit limited

println!("A byte string: {:?}", bytestring);

// Byte strings can have byte escapes...

let escaped = b"\x52\x75\x73\x74 as bytes";

// ...but no unicode escapes

// let escaped = b"\u{211D} is not allowed";

println!("Some escaped bytes: {:?}", escaped);

// Raw byte strings work just like raw strings

let raw_bytestring = br"\u{211D} is not escaped here";

println!("{:?}", raw_bytestring);

// Converting a byte array to `str` can fail

if let Ok(my_str) = str::from_utf8(raw_bytestring) {

println!("And the same as text: '{}'", my_str);

}

let _quotes = br#"You can also use "fancier" formatting, \

like with normal raw strings"#;

// Byte strings don't have to be UTF-8

let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" in SHIFT-JIS

// But then they can't always be converted to `str`

match str::from_utf8(shift_jis) {

Ok(my_str) => println!("Conversion successful: '{}'", my_str),

Err(e) => println!("Conversion failed: {:?}", e),

};

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

For conversions between character encodings check out the encoding crate.

A more detailed listing of the ways to write string literals and escape characters is given in the 'Tokens' chapter of the Rust Reference.

Option

Sometimes it's desirable to catch the failure of some parts of a program instead of calling panic!; this can be accomplished using the Option enum.

The Option enum has two variants:

   • None, to indicate failure or lack of value, and

   • Some(value), a tuple struct that wraps a value with type T.

// An integer division that doesn't `panic!`

fn checked_division(dividend: i32, divisor: i32) -> Option {

if divisor == 0 {

// Failure is represented as the `None` variant

None

} else {

// Result is wrapped in a `Some` variant

Some(dividend / divisor)

}

}

// This function handles a division that may not succeed

fn try_division(dividend: i32, divisor: i32) {

// `Option` values can be pattern matched, just like other enums

match checked_division(dividend, divisor) {