Effective Rust

Тестирование

 cargo new adder
 cd adder

 #[cfg(test)]
 mod tests {
     #[test]
     fn it_works() {
     }
 }

 cargo test

 running 1 test
 test tests::it_works ... ok
 
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

 #[test]
 fn it_works() {
     assert!(false);
 }

 running 1 test
 test tests::it_works ... FAILED
 
 failures:
 
 ---- tests::it_works stdout ----
 	thread 'tests::it_works' panicked at 'assertion failed: false', src/lib.rs:5
 note: Run with `RUST_BACKTRACE=1` for a backtrace.
 
 
 failures:
     tests::it_works
 
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
 
 error: test failed

 #[test]
 #[should_panic]
 fn it_works() {
     assert!(false);
 }

 #[test]
 #[should_panic]
 fn it_works() {
     assert_eq!("Hello", "world");
 }

 #[test]
 #[should_panic(expected = "assertion failed")]
 fn it_works() {
     assert_eq!("Hello", "world");
 }

 pub fn add_two(a: i32) -> i32 {
     a + 2
 }
 
 #[test]
 fn it_works() {
     assert_eq!(4, add_two(2));
 }

 #[test]
 fn it_works() {
     assert_eq!(4, add_two(2));
 }
 
 #[test]
 #[ignore]
 fn expensive_test() {
     // code that takes an hour to run
 }

 pub fn add_two(a: i32) -> i32 {
     a + 2
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn it_works() {
         assert_eq!(4, add_two(2));
     }
 }

 extern crate adder;
 
 #[test]
 fn it_works() {
     assert_eq!(4, adder::add_two(2));
 }

 cargo test

Итераторы

 for x in 0..10 {
     println!("{}", x);
 }

 let mut range = 0..10;
 
 loop {
     match range.next() {
         Some(x) => {
             println!("{}", x);
         },
         None => { break }
     }
 }

 let nums = vec![1, 2, 3];
 
 for i in 0..nums.len() {
     println!("{}", nums[i]);
 }

 let nums = vec![1, 2, 3];
 
 for num in &nums {
     println!("{}", num);
 }

 let nums = vec![1, 2, 3];
 
 for num in &nums {
     println!("{}", *num);
 }

 let one_to_one_hundred = (1..101).collect::<Vec<i32>>();

 let one_to_one_hundred = (1..101).collect::<Vec<_>>();

 let greater_than_forty_two = (0..100).find(|x| *x > 42);
 
 match greater_than_forty_two {
     Some(_) => println!("Found a match!"),
     None => println!("No match found :("),
 }

 let sum = (1..4).fold(0, |sum, x| sum + x);
 

 fold(base, |accumulator, element| ...).

 let nums = 1..100;

 let nums = (1..100).collect::<Vec<i32>>();

 let nums = vec![1, 2, 3];
 
 for num in nums.iter() {
    println!("{}", num);
 }

 (1..100).map(|x| x + 1);

 for i in (1..).take(5) {
     println!("{}", i);
 }

 1
 2
 3
 4
 5

 for i in (1..100).filter(|&x| x % 2 == 0) {
     println!("{}", i);
 }

 (1..)
     .filter(|&x| x % 2 == 0)
     .filter(|&x| x % 3 == 0)
     .take(5)
     .collect::<Vec<i32>>();

Многопоточность

 Send

 Sync

 use std::thread;
 
 fn main() {
     thread::spawn(|| {
         println!("Hello from a thread!");
     });
 }

 use std::thread;
 
 fn main() {
     let handle = thread::spawn(|| {
         "Hello from a thread!"
     });
 
     println!("{}", handle.join().unwrap());
 }

 use std::thread;
 use std::time::Duration;
 
 fn main() {
     let mut data = vec![1, 2, 3];
 
     for i in 0..3 {
         thread::spawn(move || {
             data[0] += i;
         });
     }
 
     thread::sleep(Duration::from_millis(50));
 }

 8:17 error: capture of moved value: `data`
         data[0] += i;
         ^~~~

 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 
 fn main() {
     let data = Arc::new(Mutex::new(vec![1, 2, 3]));
 
     for i in 0..3 {
         let data = data.clone();
         thread::spawn(move || {
             let mut data = data.lock().unwrap();
             data[0] += i;
         });
     }
 
     thread::sleep(Duration::from_millis(50));
 }

 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::sync::mpsc;
 
 fn main() {
     let data = Arc::new(Mutex::new(0));
 
     // `tx` is the "transmitter" or "sender"
     // `rx` is the "receiver"
     let (tx, rx) = mpsc::channel();
 
     for _ in 0..10 {
         let (data, tx) = (data.clone(), tx.clone());
 
         thread::spawn(move || {
             let mut data = data.lock().unwrap();
             *data += 1;
 
             tx.send(()).unwrap();
         });
     }
 
     for _ in 0..10 {
         rx.recv().unwrap();
     }
 }

 use std::thread;
 use std::sync::mpsc;
 
 fn main() {
     let (tx, rx) = mpsc::channel();
 
     for i in 0..10 {
         let tx = tx.clone();
 
         thread::spawn(move || {
             let answer = i * i;
 
             tx.send(answer).unwrap();
         });
     }
 
     for _ in 0..10 {
         println!("{}", rx.recv().unwrap());
     }
 }

Error handling

 use std::env;
 
 fn main() {
     let mut argv = env::args();
     let arg: String = argv.nth(1).unwrap(); // error 1
     let n: i32 = arg.parse().unwrap(); // error 2
     println!("{}", 2 * n);
 }

 enum Option {
     None,
     Some(T),
 }

 // Searches `haystack` for the Unicode character `needle`. If one is found, the
 // byte offset of the character is returned. Otherwise, `None` is returned.
 fn find(haystack: &str, needle: char) -> Option {
     for (offset, c) in haystack.char_indices() {
         if c == needle {
             return Some(offset);
         }
     }
     None
 }

 fn main() {
     let file_name = "foobar.rs";
     match find(file_name, '.') {
         None => println!("No file extension found."),
         Some(i) => println!("File extension: {}", &file_name[i+1..]),
     }
 }

 // Returns the extension of the given file name, where the extension is defined
 // as all characters following the first `.`.
 // If `file_name` has no `.`, then `None` is returned.
 fn extension_explicit(file_name: &str) -> Option<&str> {
     match find(file_name, '.') {
         None => None,
         Some(i) => Some(&file_name[i+1..]),
     }
 }

 fn map<F, T, A>(option: Option<T>, f: F) -> Option<A> where F: FnOnce(T) -> A {
     match option {
         None => None,
         Some(value) => Some(f(value)),
     }
 }

 // Returns the extension of the given file name, where the extension is defined
 // as all characters following the first `.`.
 // If `file_name` has no `.`, then `None` is returned.
 fn extension(file_name: &str) -> Option<&str> {
     find(file_name, '.').map(|i| &file_name[i+1..])
 }

 fn main() {
     assert_eq!(extension("foobar.csv").unwrap_or("rs"), "csv");
     assert_eq!(extension("foobar").unwrap_or("rs"), "rs");
 }

 fn file_path_ext_explicit(file_path: &str) -> Option<&str> {
     match file_name(file_path) {
         None => None,
         Some(name) => match extension(name) {
             None => None,
             Some(ext) => Some(ext),
         }
     }
 }
 
 fn file_name(file_path: &str) -> Option<&str> {
   // implementation elided
   unimplemented!()
 }

 fn and_then(option: Option, f: F) -> Option
         where F: FnOnce(T) -> Option {
     match option {
         None => None,
         Some(value) => f(value),
     }
 }

 fn file_path_ext(file_path: &str) -> Option<&str> {
     file_name(file_path).and_then(extension)
 }

 enum Result<T, E> {
     Ok(T),
     Err(E),
 }
 

 type Option<T> = Result<T, ()>; 

 impl<T, E: ::std::fmt::Debug> Result<T, E> {
     fn unwrap(self) -> T {
         match self {
             Result::Ok(val) => val,
             Result::Err(err) =>
               panic!("called `Result::unwrap()` on an `Err` value: {:?}", err),
         }
     }
 }

 try! 

 macro_rules! try {
     ($e:expr) => (match $e {
         Ok(val) => val,
         Err(err) => return Err(err),
     });
 }

 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
 fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, String> {
     let mut file = try!(File::open(file_path).map_err(|e| e.to_string()));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents).map_err(|e| e.to_string()));
     let n = try!(contents.trim().parse::<i32>().map_err(|e| e.to_string()));
     Ok(2 * n)
 }
 
 fn main() {
     match file_double("foobar") {
         Ok(n) => println!("{}", n),
         Err(err) => println!("Error: {}", err),
     }
 }

 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
 fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, CliError> {
     let mut file = try!(File::open(file_path).map_err(CliError::Io));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents).map_err(CliError::Io));
     let n: i32 = try!(contents.trim().parse().map_err(CliError::Parse));
     Ok(2 * n)
 }
 
 fn main() {
     match file_double("foobar") {
         Ok(n) => println!("{}", n),
         Err(err) => println!("Error: {:?}", err),
     }
 }

 std::error::Error 	 
 и	 
 std::convert::From 

 use std::fmt::{Debug, Display};
 
 trait Error: Debug + Display {
   /// A short description of the error.
   fn description(&self) -> &str;
 
   /// The lower level cause of this error, if any.
   fn cause(&self) -> Option<&Error> { None }
 }

 use std::io;
 use std::num;
 
 // We derive `Debug` because all types should probably derive `Debug`.
 // This gives us a reasonable human readable description of `CliError` values.
 #[derive(Debug)]
 enum CliError {
     Io(io::Error),
     Parse(num::ParseIntError),
 }

 use std::error;
 use std::fmt;
 
 impl fmt::Display for CliError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             // Both underlying errors already impl `Display`, so we defer to
             // their implementations.
             CliError::Io(ref err) => write!(f, "IO error: {}", err),
             CliError::Parse(ref err) => write!(f, "Parse error: {}", err),
         }
     }
 }
 
 impl error::Error for CliError {
     fn description(&self) -> &str {
         // Both underlying errors already impl `Error`, so we defer to their
         // implementations.
         match *self {
             CliError::Io(ref err) => err.description(),
             CliError::Parse(ref err) => err.description(),
         }
     }
 
     fn cause(&self) -> Option<&error::Error> {
         match *self {
             // N.B. Both of these implicitly cast `err` from their concrete
             // types (either `&io::Error` or `&num::ParseIntError`)
             // to a trait object `&Error`. This works because both error types
             // implement `Error`.
             CliError::Io(ref err) => Some(err),
             CliError::Parse(ref err) => Some(err),
         }
     }
 }

 trait From {
     fn from(T) -> Self;
 }

 let string: String = From::from("foo");
 let bytes: Vec<u8> = From::from("foo");
 let cow: ::std::borrow::Cow = From::from("foo");

 impl<'a, E: Error + 'a> From<E> for Box<Error + 'a>

 use std::error::Error;
 use std::fs;
 use std::io;
 use std::num;
 
 // We have to jump through some hoops to actually get error values.
 let io_err: io::Error = io::Error::last_os_error();
 let parse_err: num::ParseIntError = "not a number".parse::<i32>().unwrap_err();
 
 // OK, here are the conversions.
 let err1: Box<Error> = From::from(io_err);
 let err2: Box<Error> = From::from(parse_err);

 macro_rules! try {
     ($e:expr) => (match $e {
         Ok(val) => val,
         Err(err) => return Err(err),
     });
 }

 macro_rules! try {
     ($e:expr) => (match $e {
         Ok(val) => val,
         Err(err) => return Err(::std::convert::From::from(err)),
     });
 }

 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
 fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, String> {
     let mut file = try!(File::open(file_path).map_err(|e| e.to_string()));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents).map_err(|e| e.to_string()));
     let n = try!(contents.trim().parse::<i32>().map_err(|e| e.to_string()));
     Ok(2 * n)
 }

 use std::error::Error;
 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
 fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, Box> {
     let mut file = try!(File::open(file_path));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents));
     let n = try!(contents.trim().parse::<i32>());
     Ok(2 * n)
 }

 use std::fs::File;
 use std::io::{self, Read};
 use std::num;
 use std::path::Path;
 
 // We derive `Debug` because all types should probably derive `Debug`.
 // This gives us a reasonable human readable description of `CliError` values.
 #[derive(Debug)]
 enum CliError {
     Io(io::Error),
     Parse(num::ParseIntError),
 }
 
 fn file_double_verbose<P: AsRef<Path>>(file_path: P) -> Result<i32, CliError> {
     let mut file = try!(File::open(file_path).map_err(CliError::Io));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents).map_err(CliError::Io));
     let n: i32 = try!(contents.trim().parse().map_err(CliError::Parse));
     Ok(2 * n)
 }

 use std::io;
 use std::num;
 
 impl From<io::Error> for CliError {
     fn from(err: io::Error) -> CliError {
         CliError::Io(err)
     }
 }
 
 impl From<num::ParseIntError> for CliError {
     fn from(err: num::ParseIntError) -> CliError {
         CliError::Parse(err)
     }
 }

 use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
 fn file_double<P: AsRef<Path>>(file_path: P) -> Result<i32, CliError> {
     let mut file = try!(File::open(file_path));
     let mut contents = String::new();
     try!(file.read_to_string(&mut contents));
     let n: i32 = try!(contents.trim().parse());
     Ok(2 * n)
 }

 use std::io;
 use std::num;
 
 enum CliError {
     Io(io::Error),
     ParseInt(num::ParseIntError),
     ParseFloat(num::ParseFloatError),
 }

 use std::num;
 
 impl From<num::ParseFloatError> for CliError {
     fn from(err: num::ParseFloatError) -> CliError {
         CliError::ParseFloat(err)
     }
 }