// C++
int main() {
  // std::unique_ptr<string> hoge(new string("hoge")); と同義です。
  // 型名を 2 度書くのを避け、コード上から new をなくすことができます。
  auto hoge = std::make_unique<std::string>("hoge");
  auto piyo = std::make_unique<std::string>("piyo");
  println(*hoge);  // => hoge
  println(*piyo);  // => piyo
  hoge = std::move(piyo);  // 変数 piyo にあるポインタの所有権は変数 hoge に移ります。
  println(*hoge);  // => piyo
  println(*piyo);  // 変数 piyo は初期化されてしまっているため、メモリアクセス違反が起きます。
}

// C++
int main() {
  std::string hoge = "hoge";
  std::string piyo = "piyo";
  println(hoge);  // => hoge
  println(piyo);  // => piyo
  // hoge = piyo; と書くと文字列のコピーが発生します！
  hoge = std::move(piyo);  // 変数 piyo にある文字列の所有権は変数 hoge に移ります。
  println(hoge);  // => piyo
  println(piyo);  // => 空文字列
}

fn main() {
  let mut hoge = "hoge".to_string();  // 文字列 "hoge" を変数 hoge に入れる
  let piyo = "piyo".to_string();  // 文字列 "piyo" を変数 piyo に入れる
  println!("{}", hoge);  // => hoge
  println!("{}", piyo);  // => piyo
  hoge = piyo;  // 変数 piyo にある文字列の所有権は変数 hoge に移譲される
  println!("{}", hoge);  // => piyo
  // println!("{}", piyo);  // コメントをはずすとコンパイルエラー
}

エラー[E0382]: 移譲された値の使用: `piyo`
 --> test.rs:8:18
  |
6 |   hoge = piyo;
  |          ---- ここで値が移譲されています
7 |   println!("{}", hoge);
8 |   println!("{}", piyo);
  |                  ^^^^ 移譲された値がここで使われています
  |
  = 注釈: 移譲は `piyo` が `Copy` トレイトを実装していない型 `std::string::String` であるため起きました

// C++
#include <stdio.h>
#include <string>
 
int main() {
  std::string* a;
  {
    std::string b = "hoge";
    a = &b;
    // 変数 b の寿命（スコープ）はここまでであり、ここで文字列 hoge は解放されます。
  }
  printf("%s\n", a->c_str());  // 不正なアクセス！
}

fn main() {
  let a;
  {
    let b = "hoge".to_string();
    a = &b;  // コンパイルエラー！
  }
  println!("{}", a);
}

エラー: `b` の寿命が不十分です
 --> test.rs:5:10
  |
5 |     a = &b;
  |          ^ ここの寿命が不十分です
6 |   }
  |   - 借用された値はここまでしか生存していません
7 |   println!("{}", a);
8 | }
  | - 借用された値はここまで生存できなければなりません

fn f1(a: &String, b: &String) {}
fn f2(a: &mut String, b: &String) {}
fn f3(a: &mut String) {}
 
fn main() {
  let mut a = "hoge".to_string();  // 可変変数の宣言
  f1(&a, &a);  // 不変参照のみ借用しているので OK
  f2(&mut a, &a);  // コンパイルエラー！
  f3(&mut a);  // 可変参照を 1 つだけ借用しているので OK
  println!("{}", a);
}

エラー[E0502]: `a` はすでに可変借用をされているため、借用できません
 --> test.rs:8:15
  |
8 |   f2(&mut a, &a);
  |           -   ^- 可変借用はここまでです
  |           |   |
  |           |   不変借用がここで起きています
  |           可変借用がここで起きています

// orig に prefix が含まれていればそれを削除した orig の一部を返し、
// orig に prefix が含まれていなければ orig を返す関数です。
// 'a は寿命を表し、orig と返り値は同じ寿命であることを表します。
fn maybe_remove_prefix<'a>(orig: &'a [i32], prefix: &[i32]) -> &'a [i32] {
  if orig.starts_with(prefix) {
    return orig.split_at(prefix.len()).1;
  } else {
    return orig;
  }
}
 
fn main() {
  let mut a = [1, 2, 3];
  let mut suffix;
  {
    let b = [1, 2];
    suffix = maybe_remove_prefix(&a, &b);
    // suffix = maybe_remove_prefix(&b, &a);
    // a = [4, 5, 6];
  }
  println!("{:?}", suffix);  // => [3]
}

エラー: `b` の寿命が不十分です
  --> test.rs:18:35
   |
18 |     suffix = maybe_remove_prefix(&b, &a);
   |                                   ^ ここの寿命が不十分です
19 |     // a = [4, 5, 6];
20 |   }
   |   - 借用された値はここまでしか生存していません
21 |   println!("{}", suffix);  // => piyo
22 | }
   | - 借用された値はここまで生存できなければなりません

エラー[E0506]: 借用されているため `a` に代入することはできません
  --> test.rs:19:5
   |
17 |     suffix = maybe_remove_prefix(&a, &b);
   |                                   - `a` の借用がここで起きています
18 |     // suffix = maybe_remove_prefix(&b, &a);
19 |     a = [4, 5, 6];
   |     ^^^^^^^^^^^^^^^^^^^^^ 借用されている `a` への代入がここで起きています

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

fn main() {
  let string_value = "1234";
  // parse<i64>() は列挙型 Result<i64, ParseIntError> を返します。
  // Result<T, E> は Ok(T) および Err(E) からなる列挙型です。
  match string_value.trim().parse::<i64>() {
    Ok(x) if x < 0 => println!("負の整数: {}", x),
    Ok(x) => println!("非負整数: {}", x),
    Err(e) => println!("整数への変換に失敗しました: {}", e),
  }
}

エラー[E0004]: 不十分なパターンです: `Ok(_)` が含まれていません
 --> <anon>:5:9
  |
5 |   match string_value.trim().parse::<i64>() {
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ パターン `Ok(_)` が含まれていません

use std::ops::AddAssign;
 
// 型 T は Clone トレイト（T.clone()）と AddAssign<T> トレイト（S+=T）を
// 実装している必要があります。
fn sum<T: Clone + AddAssign<T>>(v: &Vec<T>, init: T) -> T {
  let mut result = init;
  for x in v {
    result += x.clone();
  }
  result
}
 
fn main() {
  let v = vec![10, 20, 30, 40];
  // sum<i32, i32> を呼び出します。
  println!("{}", sum(&v, 0));  // => 100
 
  let v = vec![0.01, 0.02, 0.03, 0.04];
  // sum<f64, f64> を呼び出します。
  println!("{}", sum(&v, 0.0));  // => 0.1
}

use std::ops::Add;
 
#[derive(Debug)]
struct Point(i32, i32);
 
impl Add for Point {
  type Output = Point;
 
  fn add(self, rhs: Point) -> Point {
    Point(self.0 + rhs.0, self.1 + rhs.1)
  }
}
 
fn main() {
  let result = Point(1, 2) + Point(3, 4);
  println!("{:?}", result);  // => Point(4, 6)
}

use std::thread;
use std::sync::{Arc, Mutex};
 
fn main() {
  let data = Arc::new(Mutex::new(0));
  let mut threads = vec![];
  for thread_id in 0..3 {
    println!("スレッド (ID: {}) を開始します", thread_id);
    let data = data.clone();
    threads.push(thread::spawn(move || {
      for _ in 0..100000 {
        *data.lock().unwrap() += 1;
      }
      println!("スレッド (ID: {}) が終了しました", thread_id);
    }));
  }
 
  for t in threads {
    t.join().unwrap();
  }
 
  println!("合計: {}", *data.lock().unwrap());
}

fn user_function(flag: bool) {
  // result は宣言時に初期化されていませんが、どの経路においても 1 度だけ代入され、
  // 書き換えられない変数として解釈できるのでコンパイルエラーとはなりません。
  let result : String;
  if flag {
    result = "hoge".into();
  } else {
    result = "piyo".into();
  }
  println!("{}", result);
}

エラー[E0381]: 未初期化の可能性がある変数が使われています: `result`
  --> <anon>:10:18
   |
10 |   println!("{}", result);
   |                  ^^^^^^ 未初期化の可能性がある変数 `result` が使われています

fn user_function(flag: bool) {
  // result の型はここでは宣言されていませんが、最終的に推論されます。
  // result は初期化されていませんが、どの経路においても 1 度だけ代入され、
  // 書き換えられない変数として解釈できるのでコンパイルエラーとはなりません。
  let result;
  if flag {
    // to_string() の返り値は String 型であり、
    // result の型は String 型に推論されます。
    result = "hoge".to_string();
  } else {
    // into() の返り値は result の型に依存するので、推論には用いられません。
    // result の型が String 型に推論されるので、
    // &str 型から String 型への型変換が into によって呼び出されます。
    result = "piyo".into();
  }
  println!("{}", result);
}

fn main() {
  // data は不変な &str 型
  let data = "foo,bar";
  // data は不変な Vec<&str> 型
  let data = data.split(",").collect::<Vec<_>>();
  // data は可変な String 型
  let mut data = data.join(" ");
  data += " baz";
  println!("{}", data);  // => foo bar baz
}

use std::fs::OpenOptions;
use std::io::Write;
 
// Result 型として返す値がない場合、空のタプル型を与えることができます。
fn write_foo() -> Result<(), std::io::Error> {
  // file オブジェクトは破棄されるときに自動的にファイルを閉じるので、
  // 閉じ忘れることがありません。
  // open は Result<File, std::io::Error> を返しますが、
  // 後置演算子 ? が File を返すように書き換えます（エラー時は return します）。
  OpenOptions::new().write(true).create(true).open("/tmp/foo")?.write(b"foo");
  Ok(())
}
 
fn user_function() -> Result<(), String> {
  // エラー型を変える場合は map_err メソッドで変換できます。
  write_foo().map_err(|err| format!("Failed to write foo: {}", err))?;
  Ok(())
}

macro_rules! five_times {
  ($x:expr) => (5 * $x);
}
 
fn main() {
  println!("{}", five_times!(2 + 3));  // => 25
}

• プログラミング言語Rust … Rust の公式入門ページの日本語版
• Rust Documentation … Rust の仕様書（英語）
• 関数型プログラマのためのRust … 関数型言語を理解している人向けの Rust 入門