【メモ】The Rust Programming Language

let apples = 5; // immutable
let mut bananas = 5; // muttable

std::io::stdin().read_line(&mut guess)

let mut guess = String::new();

// guessはString型
let mut guess = String::new();
// 前の値を覆い隠す
// 型変換のために変数をダブらせないため
let guess: u32 = guess.trim().parse().expect("Please type a number!");

const MAX_POINTS: u32 = 100_000;

let x = 5;
let x = x + 1;
// こっちはだめ
let x = 5;
x = x + 1;

let mut spaces = "   ";
spaces = spaces.len();

let guess: u32 = "42".parse().expect("Not a number!");

let x: (i32, f64, u8) = (500, 6.4, 1);
let five_hundred = x.0;

let a = [1, 2, 3, 4, 5];
let b = [3; 5]; // 3を5要素
let first = a[0];

let x = [式が来ることを期待]
// `let y = 6`は文であり値を返さないので、`x`に束縛するものがない
// → エラー
let x = (let y = 6);

// 値4に評価されるブロック（式）
{
    let x = 3;
    x + 1
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

if [bool型を想定した条件式] {}
else {}

let number = if condition { 5 } else { 6 };

|  let number = if condition { 5 } else { "six" };
|                              -          ^^^^^ expected integer, found `&str`
|                              |
|                              expected because of this

let x = 5;
let y = x;

let s1 = String::from("hello");
let s2 = s1;

let s1 = String::from("hello");
let len = calculate_length(&s1);

let s = String::from("hello");
change(&s);

fn change(some_string: &String) {
    some_string.push_str(", world");
    ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
}

let mut s = String::from("hello");
change(&mut s);

let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;

let s = "hello world";
let hello = &s[0..5];
let world = &s[6..11];

let mut s = String::from("hello world");
let word = first_word(&s);
s.clear(); // error!

fn first_word(s: &String) -> &str { }

let s = "Hello, world!";

// String型
let my_string = String::from("hello world");
// &str型
let my_string_literal = "hello world";

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

// 明示的に与えられてないフィールドは同じ値が入る
let user2 = User {
    email: String::from("another@example.com"),
    username: String::from("anotherusername567"),
    ..user1
};

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
// 異なるタプル構造体からインスタンスを生成
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);

struct User {
    username: &str,
    email: &str,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: "someone@example.com",
        username: "someusername123",
        active: true,
        sign_in_count: 1,
    };
}

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

enum IpAddrKind {
    V4,
    V6,
}

fn route(ip_type: IpAddrKind) { }

route(IpAddrKind::V4);
route(IpAddrKind::V6);

// 素朴な例
enum IpAddrKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

let home = IpAddr {
    kind: IpAddrKind::V4,
    address: String::from("127.0.0.1"),
};

// 列挙子に紐付ける方法
enum IpAddr {
    V4(String),
    V6(String),
}

let home = IpAddr::V4(String::from("127.0.0.1"));

enum Option<T> {
    Some(T),
    None,
}

let x: i8 = 5;
let y: Option<i8> = Some(5);
// 実際に使うにはOption<T>をTに変換する必要がある
// let y = 5;
let sum = x + y;

6 | let sum = x + y;
  |             ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

let v: Vec<i32> = Vec::new();
// 与えられた型をベクタに変換
let v = vec![1, 2, 3];

let mut v = vec![1, 2, 3, 4, 5];
let first = &v[0];
v.push(6);

let mut v = vec![100, 32, 57];
for i in &mut v { *i += 50; }

enum SpreadsheetCell {
   Int(i32),
   Float(f64),
   Text(String),
}

let row = vec![
   SpreadsheetCell::Int(3),
   SpreadsheetCell::Text(String::from("blue")),
   SpreadsheetCell::Float(10.12),
];

struct Point<T> {
    x: T,
    y: T,
}

// impl 直後の<T>の必要性
// Point<ここが具体的な型でないことを伝えたい>
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

// こっちはPoint<具体的な型>なので上記対応は不要
impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };
    // let q = Point { x: 5.0, y: 10.0 };
    println!("p.x = {}", p.x());
    // pはf32じゃないのでエラー
    // qならいける
    println!("p.x = {}", p.distance_from_origin());
}

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    // other(渡される側)は違う型の可能性あるから、違うやつ指定しないとだめ
    // 型不明な分だけ渡す
    // other: Point<V, &str>なら,  mixup<V>でOK
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c'};

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

//  trait
impl Summary for NewsArticle { }
// method
impl NewsArticle  { }

pub trait Summary {
    fn summarize(&self) -> String {
    }
}

pub fn notify(item1: &impl Summary, item2: &impl Summary) { }
//  複数の場合
pub fn notify(item: &(impl Summary + Display)) { }
//  ジェネリック型の場合
pub fn notify<T: Summary + Display>(item: &T) {

fn parse_config(args: &[String]) -> Config {
    let query = args[1].clone();
    let filename = args[2].clone();

    Config { query, filename }
}

impl Config {
    fn new(args: &[String]) -> Config {
        // バリデーション
        if args.len() < 3 {
            panic!("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();
        // インスタンス返す
        Config { query, filename }
    }
}

impl Config {
    fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();

        Ok(Config { query, filename })
    }
}

let config = Config::new(&args).unwrap_or_else(|err| {
    println!("Problem parsing arguments: {}", err);
    process::exit(1);
});

fn run(config: Config) -> Result<(), Box<dyn Error>> {