rustlingsでRustに入門する

slice

slice.rs

 let a = [1, 2, 3, 4, 5];
 let b = &a[1..4];
 assert_eq!([2, 3, 4], b);

akky

`Debug`トレイト

println!() 的なやつに出力するためには、
fmt::Display を実装するか、deriveアトリビュートを使って簡略化してしまうか(#[derive(Debug)])

akky

struct update syntax

structs.rs

 struct Color {
 	r: u8,
 	g: u8,
 	b: u8
 }
 
 let c = Color{r: 1, g: 1, b: 1};
 let c2 = Color{b: 100, ..c}; // { r: 1, g: 1, b: 100}

分割代入っぽいことができる？

akky

moduleの公開

akky

vec

vecのイテレータに対してはdereferenceが必要

vec.rs

 for i in v.iter_mut() {        
 	*i *= 2;
 }

akky

Error handling

返り値はResult<T, E> で Option<T>ではない
Ok(T) か Err(E) を返す

何でも捉えるエラー型(https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator)

error.rs

 fn main() -> Result<(), Box<dyn error::Error>> {
 }

akky

Generics

generics.rs

 struct Wrapper<T> {
     value: T,
 }
 
 impl<T> Wrapper<T> {
     pub fn new(value: T) -> Self {
         Wrapper { value }
     }
 }

generics_write.rs

 // std::fmt::Display を実装している方に制限することで、structをprintできるようにする
 impl<T: std::fmt::Display> ReportCard<T> {
 }

akky

Option型

let Some(x) = hoge みたいな代入文が作れるらしい
入れ子にすることも可能

option.rs

 fn main() {
     let optional_word = Some(String::from("rustlings"));
     // TODO: Make this an if let statement whose value is "Some" type
     if let Some(word) = optional_word {
         println!("The word is: {}", word);
     } else {
         println!("The optional word doesn't contain anything");
     }
 
     let mut optional_integers_vec: Vec<Option<i8>> = Vec::new();
     for x in 1..10 {
         optional_integers_vec.push(Some(x));
     }
 
     // TODO: make this a while let statement - remember that vector.pop also adds another layer of Option<T>
     // You can stack `Option<T>`'s into while let and if let
     while let Some(Some(integer)) = optional_integers_vec.pop() {
         println!("current value: {}", integer);
     }
 }

akky

`Arc`

変数を共有したいときに使う
例えば、並列計算を行うとき、１つの変数を複数のスレッドで触るときとか

akky

文字列

いろいろあって難しい(小並)

akky

イテレータ

collect() は謎
本当に謎

iterators.rs

 // Complete the function and return a value of the correct type so the test passes.
 // Desired output: Ok([1, 11, 1426, 3])
 fn result_with_list() -> Result<Vec<i32>, DivisionError> {
     let numbers = vec![27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
     let result: Result<Vec<i32>, DivisionError> = division_results.collect();
     result
 }
 
 // Complete the function and return a value of the correct type so the test passes.
 // Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
 fn list_of_results() -> Vec<Result<i32, DivisionError>> {
     let numbers = vec![27, 297, 38502, 81];
     let division_results = numbers.into_iter().map(|n| divide(n, 27));
     let result: Vec<Result<i32, DivisionError>> = division_results.collect();
     result
 }