Rust プログラミング・メモ

キーワードletを使って変数（識別子）を値に束縛する。
- let pat ( : type )? ( = init )?; の形式
  - 型指定 type が無くても、初期値 init や後々代入される値に基づいて、自動的に型推論される。
    - 型推論不可能な場合、エラーが出る。
  - let文で初期値を与えなくても、後で値を与えれば問題ない。
    - 未初期化変数を使用しようとした場合、エラーが出る。[#E0381]
    - unsafe な std::mem::uninitialized関数を用いて、初期化に関するコストを避けることが出来るが危険。
- 既存の変数の再定義が可能。
- C言語のような変数束縛の並列 (int a=1,b=2; のようなの) はできない。
  - let a = 1, b = 2; は不可。
  - let (a, b) = (1, 2); のようにタプルを使った同時束縛は可能。

let a = 2;
let b: f32 = 10.0;
let c;
let d: u8;
let a = a as f32 + 0.1;
let (a, b) = (a * b, (a + b).to_string());

c = 'c';
d = 10;
println!("{} {} {} {}", a, b, c, d); // 21 12.1 c 10

let e: char;
// println!("{}", e); <- error[E0381]: use of possibly uninitialized variable: `e`
//                ^ use of possibly uninitialized `e`

let mut hoge = ...; のように書くと let mut で一塊のように見えるが、実際は mut はパターンの一部なので、mut hoge で一塊となっている。
- よって次のようにも書ける。

let (mut a, ref b) = (10i32, 20i32);
a *= 2;
assert_eq!(a, *b);

ワイルドカードパターン_を値に束縛すると、その値は即捨てられる（リソース解放）。
- 以下のサンプルでは、まず _ に与えられた値が順にDropし、スコープを抜けた後、残った変数が作られた順序とは逆にデストラクタが呼ばれる。
  - ライフタイムが _a $\supsetneq$ _b $\supsetneq$ _c $\supsetneq$ _d であるため。
- トレイトの実装においてメソッドの引数が不要なとき、ダミーの引数として_を使ったりする。
  - fn foo(_: T) -> bool { false }
また識別子名をアンダーライン_から始めると、unused_variablesの警告が出ない。

use std::fmt::Display;
use std::ops::Drop;

struct Foo<T: Display>(T);

impl<T: Display> Drop for Foo<T> {
    fn drop(&mut self) {
        println!("Drop {}", self.0);
    }
}

{
    let _  = Foo("-3");
    let _a = Foo(-2);
    let _b = Foo(-1);
    let _  = Foo('0');
    let _c = Foo('1');
    let _d = Foo('2');
    let _  = Foo(3.0);
    println!("-- End of Scope --");
}

Stdout is

Drop -3
Drop 0
Drop 3
-- End of Scope --
Drop 2
Drop 1
Drop -1
Drop -2

型が不明な変数について、let a: () = を使えば簡単に型を確認することができる。
- コンパイラーがエラー文として正しい型を教えてくれる。
- 次の例では、型が std::result::Result<i32, std::num::ParseIntError> であると解る。

use std::str::FromStr;
let a: () = i32::from_str("100");
//          ^^^^^^^^^^^^^^^^^^^^ expected (), found enum `std::result::Result`
//   = note: expected type `()`
//              found type `std::result::Result<i32, std::num::ParseIntError>`

コンパイラーは賢いので、特に指示する必要の無いジェネリック型のパラメータの一部をワイルドカード_にしても、よろしく取りはからってくれる。

let a = [1, 2, 3];
let doubled: Vec<_> = a.iter().map(|&x| x * 2).collect();
// == let doubled = a.iter().map(|&x| x * 2).collect::<Vec<_>>();

assert_eq!(vec![2, 4, 6], doubled);

アイテム Items

Ref/src

アイテムとは、ソースコードにおいてアルゴリズム以外の部分、型や外部要素の利用等の宣言を行う文。
大ざっぱに キーワード識別子 { 本体部分 } の形式が多い。 - fn, trait, impl, mod, ...
- この場合、末尾にセミコロンは不要。
波括弧{}の代わりに、丸括弧()が可能な場合もある - struct, macro_rules!, ...
- キーワード識別子 ( 本体部分 ); の形式。
- この場合、セミコロン;が必要。
波括弧{}ブロックが無い、場合もある - const, use, extern crate, ...
- キーワード識別子+ 本体部分 ; の形式
- この場合も、セミコロン;が必要。

`const`アイテム

キーワードconstを用いて定数を定義する。
const定数名は、全部大文字であることが望ましい。
- これを破ると警告が出る。#[warn(non_upper_case_globals)]
let式と違い、定数の型の明示が必要。
const定数は場合により適宜プログラムにインライン展開されるので、定まったアドレスを持たないことに注意。
const mut変数を定義することは不可能。

`static`アイテム

キーワードstaticを用いてグローバル変数を定義する。
static変数名は、全部大文字であることが望ましい。
- これを破ると警告が出る。#[warn(non_upper_case_globals)]
let式と違い、またconst定数と同様に、定数の型の明示が必要。
static変数は定まったアドレスを持つことに注意。
- 故に参照は 'static ライフタイムを持つ。
static mut変数を定義することも可能
- 他のスレッドから書き換えられたりする危険性があるので、使用には unsafe が必要

static STATIC_F: f32 = 0.0;
static STATIC_F_REF: &'static f32 = &STATIC_F;
static STATIC_TEXT: &'static str = "a static str";

static mut STATIC_MUT_F: f32 = 0.0;
static STATIC_MUT_F_REF: &'static f32 = unsafe { &STATIC_MUT_F };
unsafe {
    println!("{}", STATIC_MUT_F);
    println!("{}", *STATIC_MUT_F_REF);
    STATIC_MUT_F += 1.0;
    println!("{}", STATIC_MUT_F);
    println!("{}", *STATIC_MUT_F_REF);
}

ジェネリックな関数内のstatic変数は、型パラメータを変えてもその実態が同一のものであるので注意。
- 参照：RustのGenericsを触っていて腑に落ちなかったところ

fn foo<T>() -> *mut i32{
    static mut FOO: i32 = 0;
    unsafe { println!("{}", FOO); FOO += 1; &mut FOO }
}

assert_eq!(foo::<i8>(), foo::<u8>());
assert_eq!(foo::<i8>(), foo::<f32>());
assert_eq!(foo::<i8>(), foo::<char>());
assert_eq!(foo::<i8>(), foo::<&str>());

`fn`アイテム（関数定義文）

src

関数定義はキーワードfnを用いて行う
関数本体の最後の式が戻り値となる。
- キーワードreturnを用いて、本体の記述の途中で戻り値を与えることも出来る。
- returnが使われず、本体部分の末にセミコロン;があると、戻り値はユニット()となる。
関数の本体の中で独自の関数を定義することも出来る（関数内関数）。

View アイテム

参照：クレートとモジュール

View（眺め、視界）すなわち、そのソースコードにおいて見えているもの・知っているものを左右する（i.e. 外部ソースで宣言されている関数等を既知とするための）アイテム。以下の2つ。
- extern crateアイテム - 外部クレートのインポートを宣言する。
- useアイテム - モジュール／モジュール以下の要素（関数・型・トレイト・定数など）のインポートを宣言する。
  - この「インポートを宣言」とは、ソースコードの宣言以降の部分において、宣言対象が既知となる（未知では無い＝名前解決できる）ことを意味する。
両アイテム共に、キーワードasを用いて宣言対象に別名を与えることが出来る。

`extern crate`アイテム

`use`アイテム

mod アイテムには以下の 2 つの機能がある。
- ローカルスコープに名前をインポートする。
  - use path::name; の形式。
- ローカルスコープで新しい名前にバインドする。
  - use path::old_name as new_name; の形式。
use module_a::module_b::AType::{Self, VariantA, VariantB}; のように複数の名前を同時にインポートできる。
- ここの Self は use module_a::module_b::AType; と等価。
参考リンク：Rustで use std; が必要なときとエラーになるときがあるのは何故か - 簡潔なQ

`mod`アイテム

mod アイテムには以下の 2 つの種類がある。
- 特別なファイル (mod.rs等) において、モジュールの使用を宣言する。
  - mod mod_name; の形式。
- mod ブロック - ファイル分割無しに、新規モジュールを作成できる。
  - mod new_mod_name { items } の形式。
- 以上2つ共に、pub修飾子が頭に付くこともある。

その他アイテム

externアイテム
global_asm!アイテム
typeアイテム
カスタム型宣言アイテム
- enumアイテム
- structアイテム
- unionアイテム
traitアイテム
implアイテム
マクロ発動アイテム
マクロ定義アイテム

式 Expressions

Ref/Grm/src

繰り返し（ループ）式 Loops

Ref/1st/Jpn/src

while, loop, for 等々のループ式があるが、~~いずれも全てユニット型 () のみを返す。~~¹
- v1.19よりbreakキーワードを用いることで、ユニット型以外も返せるようになった。See RFC 1624.

loopループ - Ref/Grm. 無限ループ
- loop { body } の形式
- body ブロックにおいて break でループを脱出しないと、無限ループとなる。
whileループ - Ref/Grm. 条件ループ
- while expr { body } の形式
- 条件式部分で波括弧{,}で括り式を並列させることで、少なくとも1回は body ブロックを実行する、いわゆる do-while ループを再現できる。
  - while { body; expr } {} の形式
    - ダミーの本体ブロックとして、尻に {} が付くことに注意。
forループ - Ref/Grm. イテレータ（反復子）ループ
- for val in expr { body } の形式
- トレイトstd::iter::IntoIteratorを実装してイテレータへと変換可能な式 expr の要素を走査する

// while
let mut i = 0;
while i < 10 { i += 1; }
assert_eq!(i, 10);

// like do-while
while {
    i += 1;
    i < 10
} {}
assert_eq!(i, 11);

// for
for c in vec!('H','e','l','l','o','!') {
    println!("{}", c);
}

// loop
let a = loop { break; };
let b = loop { break 10; };

assert_eq!(a, ());
assert_eq!(b, 10);

ループ・ラベル Loop labels

Ref/1st/Jpn/src

シングルクォート'とコロン:を用いて、各種ループ式にラベルを付けられる。
- 'label_name: keyword の形式
  - ここで label_name はラベルの名前となる識別子、keyword は loop, while, for のいずれかのキーワード。
キーワードbreak/キーワードcontinueを用いて、ループの脱出／続行を行う。
- break; / continue; - この式を囲む最内ループから脱出／続行する。
- break expr; - break式に値を与えることで、この式を囲む最内ループの戻り値を、ユニット()から expr へと変更できる。
- break式、continue式にラベル名を与えることで、ラベル名で指名したループからの脱出／続行が行える。
  - break 'foo;
  - break 'foo value; - breakで値を返すときは、ライフタイム-値の順で書く。
  - continue 'bar;

let mut i = 0;
let value = 'loop1: loop {
    'loop2: for j in 0..10 {
        let mut ks = 0..j+1;
        'loop3: while let Some(k) = ks.next() {
            if j % 2 == 0 { continue 'loop2; }
            if k % 2 == 0 { continue 'loop3; }
            println!("{} {} {}", i, j, k);
            i += 1;
            if i > 10 { break 'loop1 i + j + k; }
        }
    }
};
println!("value: {}", value);

マッチ式 `match` expressions

matchキーワードを用いて、パターンマッチを行う。
match expr { pattern-list } の形式
各マッチ節が返す値の型は、全て一致しなくてはならない。
- match x { 10 => "Ten", _ => 0, }; // Error: note: match arm with an incompatible type

パターン Patterns

1st/Jpn/src

パターンはmatch式だけでなくlet文でも使われる重要な要素である。
次のmatch式で具体例を参照せよ。

for x in 0..14 {
    let text = match x {
        0 => "zero",
        1 | 2 => "one, two",
        3 ... 5 => "さん, よん, ご",
        x @ 6 ... 7 => match x { 6 => "六", 7 => "七", _ => unreachable!() },
        x @ 8 ... 9 | x @ 10 ... 11 if x%2 == 0 => "捌, 拾",
        8 ... 11 => "nine, eleven",
        _ => ">=12",
    };
    println!("{}: {}", x, text);
}

浮動小数点数をパターンで使うと、警告が出るので注意。
| で並列
... で範囲。
- レンジ式の..と違い、first ... end においては最終要素 end も含まれる (inclusive) なので注意
- （少なくとも現在では）特定のプリミティブ（数値型や文字型）に対してしか使えないようなので注意。
@ で変数に束縛
- | と同時に使うときは、同じ変数への束縛を再明示
if でガード
- pat₁ | pat₂ if gud は、pat₁ | (pat₂ if gud) ではなく (pat₁ | pat₂) if gud 的な意味なので注意
  - i.e. | は if より優先度が高い
マッチングは頭から行われる
_ はワイルドカード

`if let`式 `if let` expressions

式とパターンマッチを試して、変数束縛を行う。
if let pat = expr { body } else_tail ? の形式
- パターンは等号=の左辺（右辺には置けない）。
常に成立する（マッチに失敗しない）パターンについては、if let式を組むとエラーが出る。[#E0162]
- この場合let文を使えということだ。

let val = ("tagA", "a body", "tagB");

if let ("tagA", body, _) = val {
    println!("tagA's body: {}", body);
} else {
    println!("unmatch");
}

if let (_, body, "tagB") = val {
    println!("tagB's body: {}", body);
}

`while let`式 `while let` expressions

ループ式の一種。
whileループにおいて、再帰の度に行われる条件式で変数束縛を行う。
- 毎回 if let を行い、if let に失敗したら再帰終了的な。

let mut x = vec![1, 2, 3];

while let Some(y) = x.pop() {
    println!("y = {}", y);
}
// y = 3, y = 2, y = 1

レンジ式 Range expressions

Ref/Grm/src

..演算子を用いて、範囲を表す構造体を簡単に記述するための記法。
- 演算子の優先順位の表を見て分かるとおり、..演算子の優先度は低い。
  - そのため 1+2*3 .. 10i32.pow(2)-10 のように式を組み合わせたレンジ式において、(1+2*3) .. (10i32.pow(2)-10) のような括弧は不要。
レンジ式は 0 .. 0 や 0 .. -10 のような start ≥ end のような式も受け付けるが、中身は空。
- assert_eq!(0, (0 .. -10).len());
std::collections::rangeモジュールにおいて、より発展的なRangeArgumentトレイトが与えられているが、まだ実験的 (collections_range #30877)

4種のレンジ式

start..end - 構造体 std::ops::Range を表す。
- 半開区間 [start, end)
- 最終要素 end は含まれない (exclusive) に注意
start.. - 構造体 std::ops::RangeFrom を表す。
- 区間 [start, +∞)
..end - 構造体 std::ops::RangeTo を表す。
- 区間 (-∞, end)
.. - 構造体 std::ops::RangeFull を表す。
- 全区間 (-∞, +∞)

# ![feature(range_contains)]
# ![allow(unused_variables)]
use std::ops::*;

let a : Range<i32> = 1..10;
let b : RangeFrom<i32> = 1..;
let c : RangeTo<i32> = ..10;
let d : RangeFull = ..;

assert_eq!(a, Range{ start: 1, end: 10 });
assert_eq!(b, RangeFrom{ start: 1 });
assert_eq!(c, RangeTo{ end: 10 });
assert_eq!(d, RangeFull);

assert!(!a.contains(0) && a.contains(1) && !a.contains(9) && !a.contains(10));
assert!(!b.contains(0) && b.contains(1) &&  b.contains(9) &&  b.contains(10));
assert!( c.contains(0) && c.contains(1) && !c.contains(9) && !c.contains(10));
// assert!( d.contains(0) && d.contains(1) &&  d.contains(9) &&  d.contains(10));
// RangeFull は contains() メソッドを持たなかった。

演算子式 Operator expressions

Ref/src

殆どの演算子はオーバーロード可能。
各種演算子は以下のモジュールで扱われる。

std::ops
- 単項算術・論理演算子 - -, !
- 二項算術・論理演算子
 - 二項算術演算子 - +, -, *, /, %
 - 二項ビット演算子 - |, &, ^, <<, >>
- 複合代入演算子
 - 算術代入演算子 - +=, -=, *=, /=, %=
 - ビット代入演算子 - |=, &=, ^=, <<=, >>=
- 特殊演算子 - *, []
- 関数呼び出し演算子 - ()
- その他 - ?, <-
std::cmp
- 比較演算子 - ==, !=, <, >, <=, >=
不明
- 遅延ブール演算子 - &&, ||
? はトライ演算子。? 演算子の節で詳しく述べる。
<- は実験的な placement-in 演算子。#![feature(placement_in_syntax)] で使える。
- std::vec::Vec::place_back()を参照
インクリメント／デクリメント演算子++,--は無い
- 何故かというと、(前置|後置)(イン|デ)クリメントの評価順序の複雑性がしばしばバグの温床となるから。See FAQ: Why doesn't Rust have increment and decrement operators?

演算子の優先順位 Operator precedence

Ref/src

次の表で、演算子を優先順位降順に並べる。
- 単項演算子は二項演算子より優先されることが分かる。
  - より正確には、後置単項演算子 > 前置単項演算子 > 二項演算子の順。
- 「非結合」演算子では、その結合を丸括弧 (,) で明示しないと文法エラーとなる。
  - a == b == c - Error
  - (a == b) == c - OK
フィールド演算子.は?より強い。よって &self.hoge?は&((self.hoge)?)となる。

演算子	結合性
`?`
単項 `-` `*` `!` `&` `&mut`
`as` `:`	左結合
`*` `/` `%`	左結合
`+` `-`	左結合
`<<` `>>`	左結合
`&`	左結合
`^`	左結合
`\|`	左結合
`==` `!=` `<` `>` `<=` `>=`	非結合
`&&`	左結合
`\|\|`	左結合
`..` `...`	非結合
`<-`	右結合
`=` `+=` `-=` `*=` `/=` `%=` `&=` `\|=` `^=` `<<=` `>>=`	右結合

`?` 演算子 The `?` operator

Ref/std/src

v1.13より導入された、エラー処理用の演算子。try!マクロの代わり。
? 演算子オーバーロード用にstd::ops::Tryトレイトは用意されているが、あくまで実験段階。

std::result::Result<T, E> 型の変数に対して後置で作用し、変数の値が

Ok(x) なら、unwrap して x を継続に渡す
Err(e) なら、（関数またはクロージャーの戻り値の型に合わせて）Err(From::from(e)) をreturnする。

fn try_to_parse() -> Result<i32, ParseIntError> {
    let x: i32 = "123".parse()?; // x = 123
    let y: i32 = "24a".parse()?; // returns an Err() immediately
    Ok(x + y)                    // Doesn't run.
}

let res = try_to_parse();
println!("{:?}", res);

v1.22より、?演算子がOption<T> 型に対しても作用するようになった。
すなわち Option が Try トレイトを実装した。

Some(x) なら、x を継続に渡す。
None なら、None をreturnする。

fn option_try_test(opt: Option<i32>) -> Option<i32> {
    let x = opt?;
    Some(x * 2)
}
assert_eq!(option_try_test(Some(10)), Some(20));
assert_eq!(option_try_test(None), None);

try_trait #42327により、Option<T>型に対する?演算子でResult<T,NoneError>型の返り値にも対応する。

Some(x) なら、x を継続に渡す。
None なら、ユニットライク構造体std::option::NoneErrorをErrで包んでreturnする。

# ![feature(try_trait)]

use std::option::NoneError;

fn option_try_test2(opt: Option<i32>) -> Result<i32, NoneError> {
    let x = opt?;
    Ok(x * 2)
}
assert_eq!(option_try_test2(Some(10)), Ok(20));
assert_eq!(option_try_test2(None), Err(NoneError));

`box` 式

Old/Jpn/src

[Experimental] (box_syntax #27779)

キーワード box を用いて、与えられた式をヒープへと直接書き込む box 式を記述する。
- box expr の形式
- 巨大な値を効率よく扱うために用いる。
例えば次の文は容易く error: stack overflow を引き起こす。（参考: Rustで巨大なヒープメモリを取る）

let buf = Box::new([0; 1024*1024*4]);

しかし次のように box 式を用いると、式 [0; 1024*1024*4] の（評価）結果はスタックを経由せず、ヒープへと直接書き込まれるため、スタック・オーバーフローを回避できる。
- そしてこの box 式は、型 Box<[i32; 4194304]> の値を返す。

# ![feature(box_syntax)]
let buf = box [0; 1024*1024*4];

プリミティブ型 Primitive Types

Ref/1st/std
以下のプリミティブ型が用意されている。

u8, i8, u16, i16, u32, i32, u64, i64, usize, isize - 語るまでも無い整数値型。
f32, f64 - 浮動小数点数。様々な初等算術メソッドが用意されている。
bool - 真偽値
char - 文字型
array - スタック上の配列
str - 文字列
slice - スライス
tuple - タプル、直積型
pointer - ポインタ

let a_int: i32 = 10;
let a_num: f32 = 1.0;
let a_boolean: bool = true; // or false
let a_char: char = '❤';
let an_array: [i32; 3] = [1u32, 2, 3];
let a_str: &a_str = "text";
let a_slice: &[i32] = &an_array[0..2];
let a_tuple: (&'static str, i32, char) = ("hello", 5, 'c');
let a_ptr: *const i32 = &10i32;

タプル Tuple types

Ref/1st/Grm/Ex./Jpn

タプルの要素には、let文やif let式、ドット記法でアクセスできる。
- ドット記法の添字は 0 から始まる。
1要素タプルには曖昧さ排除のため、型名・リテラル共にカンマ,が必要。
- let one_element_tuple: (i32,) = (10,);

let a_tuple: (bool, i32, f32) = (true, 10, 0.0);

let (head, body, _) = a_tuple;
assert_eq!(head, true);
assert_eq!(body, 10);

if let (true, _, last) = a_tuple {
assert_eq!(last, 0.0);
}

assert_eq!(a_tuple.0, true);
assert_eq!(a_tuple.1, 10);
assert_eq!(a_tuple.2, 0.0);

ユニット型 the unit type

0要素タプル型 () は特別に「ユニット型」と呼ばれる。
ユニット型の値はユニット () ただ一つ。
C言語の void 的な、または空集合。
セミコロン;で終わる式文や文はユニットを返す。
型のサイズは 0.
- assert_eq!(size_of::<()>(), 0);

アレイとスライス Array, and Slice types

Ref/Ex.

アレイ / Array / `std.primitive.array`

スタック上の固定長配列。[T; N]が配列の型。

アレイ式 Array expressions

Ref/Grm

[1, 2, 3, 4];
["a", "b", "c", "d"];
[0; 128];

スライス型 / Slice types / `std.primitive.slice`

隣接 (contiguous) するデータ型への動的サイズの参照（ビュー）。
- 動的なので型に長さ情報を持たない。
&[T]がスライスの型。

スライシング構文 Slicing syntax

// A stack-allocated array
let array: [i32; 3] = [1, 2, 3];

// A heap-allocated array
let vector: Vec<i32> = vec![1, 2, 3];

// A slice into an array
let slice: &[i32] = &vector[..];

ベクタ Vectors

std::vec::Vec はヒープ上に確保された配列を扱うジェネリック構造体。
- プリミティブ型ではない。
生成にはもっぱらマクロ vec! を使う。
参考ソース libcollections/macros.rs

let v1: Vec<i32> = vec![1, 2, 3, 4]; // 要素を列挙

let v2 = vec![0; 5]; // vec![初期値; 個数]
assert_eq!(v2, vec![0,0,0,0,0]);

let mut v: Vec<i32> = Vec::new();
v.push(1); v.push(2); v.push(3); v.push(4);
assert_eq!(v, v1);

文字列 Strings

1st/Grm/Ex./Jpn

&str - 文字列のスライス型。
- &'static str - リテラルにより生成されるプリミティブ型。
String - UTF-8 エンコードされた文字列。文字列操作するならもっぱらこれを用いる。

文字列リテラル String literals

let a: &'static str = "foobar";
let b = "foo\
         bar";
assert_eq!(a,b);

Raw 文字列リテラル Raw string literals

rに続く n (>=0) 個の#に続く"で始まり、"に続く n 個の#で終わる範囲を文字列とする Raw 文字列リテラル。
- Raw 文字列リテラルの中にはエスケープが存在しないので、r#"〜"# の中に文字列 "\"#" を入れることは出来ない。
  - 代わりに r##"…"## を使おう。

let s1 = "text";
let s2 = r"text";
let s3 = r#"text"#;
let s4 = r##"text"##;
assert_eq!(s1, s2);
assert_eq!(s1, s3);
assert_eq!(s1, s4);

バイト文字列リテラル Byte and byte string literals

"で括った文字列／Raw 文字列リテラルにbの接頭辞で、バイト文字列になる。
- 型はu8のアレイ: [u8: n] の'static参照。
- ASCII コードしか含められない。

let s1: &'static [u8; 4] = b"text";
let s2: &'static [u8; 4] = br"text";
let s4: &'static [u8; 4] = br##"text"##;
assert_eq!(s1, s2);
assert_eq!(s1, s4);

カスタム型

メモリサイズにより以下に分類される。
- 固定サイズ型 fixed-sized types
- 動的サイズ型 Dynamically Sized Types (DSTs) - Nom/NoJ
- ゼロサイズ型 Zero Sized Types (ZSTs) - Nom/NoJ
- 空型 Empty Types - Nom/NoJ
v1.18より、#[repr]属性を持たないタプル・列挙型・構造体は、サイズを最小化するため自動的に（内部変数が）再配置される可能性がある。See Pull #40377.
enum Option<T> { None, Some(T), } のような列挙型については、None値をnullポインタで判別し、タグを付け足したりしない最適化が行われる。 - Nullable enum optimizations
- See RustのNULLポインタ最適化 - 簡潔なQ

構造体 Structs

Ref/1st/2nd/Grm/Ex./Jpn

.. でフィールドの一部コピーが簡略化できる。
- 構造体パターンにおいて、構造体要素名の省略にも使える。
v1.17より、構造体の内部変数名と同一の変数については、コンストラクタにおいて添字を省略できる。See RFC 1682.
- 構造体パターンにおいても同様。

# [derive(PartialEq, Debug)]
struct Point4d {
    x: i32, y: i32, z: i32, w: i32,
}

let origin = Point4d { x: 0, y: 0, z: 0, w: 0};
let point1 = Point4d { z: 1, x: 2, .. origin };

let (x, y, z, w) = (point1.x, point1.y, point1.z, point1.w);
let point2 = Point4d { x: x, y: y, z: z, w: w }; // old
let point3 = Point4d {    x,    y,    z,    w }; // RFC 1682

assert_eq!(point1, Point4d { x: 2, y: 0, z: 1, w: 0});
assert_eq!(point1, point2);
assert_eq!(point1, point3);

let point4 = Point4d { x: 20, y: 10, z: 11, w: 0};
//  構造体の分解
let Point4d { x: x2, z, ref y, .. } = point4; // ここで `z: z` とする必要は無い。
assert_eq!(x2, 20);
assert_eq!(*y, 10);
assert_eq!(z, 11);

タプル構造体 Tuple structs

タプルのように、丸括弧(,)で型を囲んで定義する構造体。
- 要素に名前を持たない。
- 基本的に1要素タプル構造体しか使われない。
  - 1要素タプル構造体は、他の型のラッパーを作るのに便利。See 例
- タプルと同様に、0 から始まる自然数によるドット記法で内部値へアクセスできる。

struct Color(i32, i32, i32);
let c = Color(10, 20, 30);
assert_eq!(c.0, 10);

struct Inches(i32);

let length = Inches(10);

let Inches(integer_length) = length; // let を用いた内部値の取りだし。
println!("length is {} inches", integer_length);

v1.19よりタプル構造体は、自然数名の変数を持つ構造体のようにも構築することが出来るようになった。See RFC 1506.

# [derive(PartialEq, Debug)]
struct Point(u32, u32);

let x = Point { 0: 3, 1: 5 };
let y = Point { 1: 5, 0: 3 };

assert_eq!(x, y);

Unit-like 構造体 Unit-like structs

ゼロ要素タプル（ユニット型） () のように、内部に値を持たない構造体。

struct Electron;
let x = Electron;

列挙型 Enums

Ref/1st/2nd/Ex./Jpn

内部に値を持てるので色々と便利に使える。「タグ付き共用体」

enum Message {
    Quit,                       // Unit-like 構造体変数
    ChangeColor(i32, i32, i32), // タプル構造体変数
    Move { x: i32, y: i32 },    // 構造体
    Write(String),              // タプル構造体変数
}

C-like 列挙型 C-like enums

Ex.

内部値を持たない C-like 列挙型は、C言語のように数値型へと変換することが出来る。(See 1st/Jpn)
- その値を明示的に与えることも出来る。
- 数値型から列挙型への変換は一手間必要 (See サンプル)

# ![allow(dead_code)]

 Number {
    Zero, One, Two,
}

# [derive(Debug, Copy, Clone)]
enum Color {
    Red   = 0xFF0000,
    Green = 0x00FF00,
    Blue  = 0x0000FF,
}

fn main() {
    use Number::*;
    println!("zero is {}", Zero as i32);
    println!("one is {}", One as i32);
    
    use Color::*;
    println!("{:?} is 0x{:06X}", Red, Red as i32);
    println!("{:?} is 0x{:06X}", Blue, Blue as i32);
    let color: Color = unsafe { std::mem::transmute(0x00ff00) };
    println!("0x{:06X} is {:?}", color as i32, color);
}

空列挙型

空な列挙型は、普通の列挙型とは異なる挙動を示す。
- See Rust パターンマッチの網羅性 - 簡潔なQ, rust/RELEASES.md Version 1.16.0 (2017-03-16) > Issue #12609, feature(never_type)

# ![feature(never_type)]
# [allow(dead_code)]

enum Empty { }

fn test0(x: Empty) {
    match x {
        _ => unreachable!(), // warning: unreachable pattern
    }
}
fn test1(x: Empty) {
    match x {
        // no pattern is valid.
    }
}
fn test2(x: Option<Empty>) {
    match x {
        None => println!("Hello"),
        Some(_) => unimplemented!(), // warning: unreachable pattern (only if #![feature(never_type)])
    }
}

共用体 union

v1.19より、C言語にあるような共用体（タグ無し共用体）がサポートされた。See RFC 1444.

キーワードunionを用いて定義
変数へのアクセスには unsafe が必要
- 共用体はどの内部値で定義されたかを覚えていないので、異なる型へのアクセスが危険だから。
パターンマッチも可能。しかし繰り返すが、共用体は内部型を記憶しないので、let MyUnion { i } = a;のようなパターンマッチは常に成功することに留意されたし。

union MyUnion {
    f: f32,
    i: i32,
    x: [u8;4]
}
let a = MyUnion { f: 1.0 };
println!("a.f: {:.3}", unsafe { a.f });
println!("a.i: {}", unsafe { a.i });
println!("a.i: 0x{:08X}", unsafe { a.i });
println!("a.i: 0b{:032b}", unsafe { a.i });
println!("a.x: {:?}", unsafe { a.x });
unsafe { println!("a.x: 0b{:08b}_{:08b}_{:08b}_{:08b}", a.x[3], a.x[2], a.x[1], a.x[0]); };

unsafe {
    let MyUnion { f: fval } = a;
    let MyUnion { i } = a;
    println!("{:0.3} == {}", fval, i);
}
unsafe {
    match a {
        MyUnion { i: 0...10 } => println!("{}", a.i),
        MyUnion { f: fval } if fval == 1.0 => println!("{}", fval),
        MyUnion { f } => println!("{}", f),
    }
}

言語機能

型キャスト Casting Between Types

1st/Grm/Jpn

型強制 Type coercions

Ref/1st/Jpn

型強制とは（唯一）暗黙的に行われる以下の変換

mutableな参照（ポインタ）のimmutable化
- &mut T -> &T
- *mut T -> *const T
参照からポインタへの変換
- &T -> *const T
- &mut T -> *mut T
- ポインタから参照への変換には、&*等が必要（See 参照と生ポインタ）
参照外し演算子 * (Deref) （See Deref による型強制）
- 引数やメソッド呼び出しに際して、必要に応じて*は幾らでも自動的に挿入される（See Derefとメソッド呼び出し）
 - 例えば構造体std::vec::Vec<T>は、これ自身はiter()メソッドを実装していないが、Deref<Target=[T]>を実装しているため、暗黙のDerefによる[T]への型変換経由で、iter()メソッドを呼び出すことが出来る。
- この暗黙の Deref を用いて、「クラス継承」を再現できる。

fn test1(ptr: *const i32) { println!("{}", unsafe { *ptr }); }
fn test2(rf: &i32) { println!("{}", *rf); }

let rf: &i32 = &100;
let ptr: *const i32 = &100; // 暗黙変換
test1(rf);
//test2(ptr); // Error
test2(unsafe { &*ptr });

let v: Vec<i32> = vec!(1, 2, 3, 4);
let mut iter = v.iter(); // called [i32]::iter(& *v)
assert_eq!(iter.next(), &1);

`as`（安全キャスト）

See Issue #35919: Adding type annotation equivalent to existing type changes code semantics

キーワード as を用いて安全なキャストを行う。
安全なキャストには以下の 3 種がある。
- 明示的型強制 - 型強制で行われる型の変換を、明示的に行う。
- 数値キャスト
  - 数値型同士の変換
  - C-likeな列挙型を整数型へ
  - 真偽値boolや文字型charを整数型へ
  - u8を文字型charへ
- ポインタキャスト - 生ポインタと整数型の間の相互変換
Cとは違い、Rust では数値型が暗黙に適当に型変換されることは無いので、例えば1 + 1.0 のような式はエラーとなる。
- 1 as f32 + 1.0 のように明示的に型を揃えるためのasキャストが必要。
- 演算子の優先順位の表を見て分かるとおり、asは二項演算子の中では一番優先順位が高い。
  - 故に、普通の数値演算において (1 as f32) + 1.0 のような括弧()は不要である。

`transmute`

1st/std/Jpn

関数 std::mem::transmuteを用いて、unsafe な型変換が行える。
- ビット単位の再解釈を行う。
  - そのため、型変換について型サイズの一致は確認する。
    - 違反するとエラーが出る。[#E0512]
- 標準ライブラリのドキュメントに多くの例が挙げられているが、
  - ライフタイムの伸張といった、とんでもないことも行える。

use std::mem::transmute;

unsafe {

println!("{:?}", transmute::<_, [u8; 4]>(1.0f32));
println!("{:?}", transmute::<_, [u8; 8]>(1.0f64));
println!("{:?}", transmute::<_, [u8; 8]>(100i64));
let a: String = "Hello".to_string() + " World!";
println!("{:?}", transmute::<_, &'static str>(a.as_str()));

}

変換関数の例

String -> &str
- String::as_str(&self)
- トレイトBorrow<str>
 - String::borrow(&self)
String -> Box<str>
- トレイトFrom<String>
 - Box<str>::from(s: String)
&str -> String
- トレイトToString
 - str::to_string(&self)
- トレイトToOwned<Owned = String>
 - str::to_owned(&self)
- トレイトFrom<&'a str>
 - String::from(s: &'a str)

所有権 Ownership

1st/Jpn/ExJ

Rust は所有権システムにより、1つのリソースは1つの変数にしかその所有権が持たれていないことを保証する。

「変数」が「リソース（値、変数の中身）」について「所有権」を持っている。
- リソースの所有権は他の変数への代入や関数適用時に、他の変数や関数（の引数）にムーブ move される。
- リソースの所有権を失った変数はいわば抜け殻のようなもので、そのリソースへのアクセスはコンパイラエラーを引き起こす。(use of moved value #E0382)
  - mut変数なら、代入されることで再度リソースの所有権を保有することが出来る。
- リソースが Copy トレイトを実装していたら、所有権のムーブではなく、リソースのコピーが行われ、元の変数の所有権は失われない。

# ![allow(unused_variables)]

# [derive(Debug)]
struct Foo(i32);

let a = Foo(100); // `Foo(100)` というリソースの所有権を変数 `a` が持っている。
//  ここで1要素タプル構造体 `Foo(i32)` を用いたのは、普通の数値型だと `Copy` を実装しているので、
//  所有権がムーブしないため。

let mut b = a; // 変数 `a` の持つ `100` への所有権が変数 `b` へとムーブされた。
//  println!("{:?}", a); // <- 変数 `a` の持つリソースは既にムーブされているので、
//  コンパイルエラーが生じる。

let c = b;
b = c;  // 変数 `b` はmut変数なので、再度リソースを代入できる。

let d = b.0;    //  変数 `b` の要素 `b.0` の型は `i32` で `Copy` を実装しているため、
                //  新しい変数 `d, e` へとリソース `100` がコピーされる。
let e = b.0;    //  変数 `b` の所有権は失われない。

fn consume_foo(_foo: Foo) {}

consume_foo(b);
//  println!("{:?}", b);    //  既に関数 `consume_foo`（、正確にはその引数 `_foo`）へと
//  変数 `b` の所有権がムーブされているので、コンパイルエラーが生じる。

所有権を持つ変数が失われたとき、リソースは解放される。
- 「変数が失われたとき」とは、処理がリソースを所有している変数の宣言されたスコープを抜ける、変数に所有されないリソースがワイルドカード_に代入される、などのとき。
- こうしてリソースが1回だけしか解放されないことが保証される。
- タプルや構造体の要素は個別にムーブ、解放される。

# ![allow(unused_variables,non_snake_case)]

# [derive(Debug)]
struct Foo(char);

impl Drop for Foo {
    fn drop(&mut self) { println!("Drop {:?}", self); }
}

println!("in #1");
{
    let a = Foo('a');
    let _ = Foo('_');   //  即値がワイルドカードにマッチされるとき、
                        //  このリソース`Foo('_')`を持つ変数がないので即ドロップ
    let b = Foo('b');
    let _ = b;          //  `Foo('b')`は変数`b`が持ったままなので、この行に意味は無い。
    println!("in #1.1");
    {
        let A = Foo('A');
        let B = Foo('B');
        let C = Foo('C');
        //  このブロックは、`{ let A = ...; { let B = ...; { let C = ...; }}}`
        //  と等価なので、`C, B, A` の順にドロップする。
    }
    println!("in #1.1");
    let c = Foo('c');
}
println!("out #1");

println!("in #2");
{
    let v012 = (Foo('0'), Foo('1'), Foo('2'));
    println!("in #2.1");
    {
        let (v0, _, v2) = v012;
        //  `v0`,`v2` に所有された `Foo('0'), Foo('2')` はここでドロップ
    }
    println!("out #2.1");
    //  println!("{:?}", v012.0);   //  `v012.0, v012.2` は既にムーブしているのでアクセスできない
    //  println!("{:?}", v012.2);
    println!("{:?}", v012.1);
    //  残りの `v012.1` の所有する `Foo('1')` はここでドロップ
}
println!("out #2");

println!("in #3");
{
    struct Bar { a: Foo, b: Foo, cd: (Foo, Foo) };
    //  `Bar`が`Drop`を実装していないから、以下のようなことが可能
    
    let bar = Bar { a: Foo('a'), b: Foo('b'), cd: (Foo('c'), Foo('d')) };
    println!("in #3.1");
    {
        let Bar { a, b: _, cd: (c, _) } = bar;
        //  `a`,`c` に所有された `Foo('a'), Foo('c')` はここでドロップ
    }
    println!("out #3.1");
    //  println!("{:?}", bar.a);    //  `bar.a, bar.cd.0` は既にムーブしているのでアクセスできない
    //  println!("{:?}", bar.cd.0);
    println!("{:?}", bar.b);
    println!("{:?}", bar.cd.1);
    //  残った `bar.b, bar.cd.1` の所有する `Foo('b'), Foo('d')` はここでドロップ
}
println!("out #3");

Dropトレイトを実装している型は、その部分要素をムーブすることができない。
- コンパイルエラー#E0509を生じる。
- 構造体分解も出来ない。

# [derive(Debug)] struct Foo(char);
# [derive(Debug)] struct Bar(Foo);

impl Drop for Foo { fn drop(&mut self) { println!("Drop {:?}", self); } }
impl Drop for Bar { fn drop(&mut self) { println!("Drop {:?}", self); } }

let foo = Foo('a');
let a = foo.0;  //  これはコピーだからOK
let bar = Bar(foo);
//  let foo = bar.0;    //  これはムーブになるからNG
//  let Bar(foo) = bar; //  構造体パターンによる分解も、要素のムーブになるからNG

Boxは言うまでもなくDropを実装した型であり、そのためBox<T>の成分取り出しはTの場合のようには行かない。
- 単純に行うと、1つ成分を取り出すとその時点でBox値が consume され、2つ目の成分が取り出せない。(box test 1)
- 値を一旦スタック上に移して、それから取り出す手も有る。(box test 2)
- ブロックで囲むことで、box test 2 と同様に。(box test 3)
- 自分自身を返すメソッドを実装する手もある。(box test 4)
- ブロックで囲む box test 3 が一番単純な手だとは思うが、スマートじゃないような……

//  prelude
# ![allow(unused_variables)]
struct Foo(i32);
struct Bar(Foo,Foo);

//  stack test
let bar = Bar(Foo(0), Foo(1));
let Bar(foo0, foo1) = bar;  //  OK

//  box test 1
let bar = Box::new(Bar(Foo(0), Foo(1)));
//  let Bar(foo0, foo1) = *bar; //  NG. `bar.0` が `foo0` へとムーブされた時点で `bar` は
                                //  consume され、`bar.1` へとアクセス出来なくなる。
let Bar(foo0, _) = *bar;    //  成分を1つかし取り出さない、これは OK

//  box test 2
let bar = Box::new(Bar(Foo(0), Foo(1)));
let Bar(foo0, foo1) = { let tmp = *bar; tmp };  // これは OK

//  box test 3
let bar = Box::new(Bar(Foo(0), Foo(1)));
let Bar(foo0, foo1) = { *bar }; //  box test 2 より、これも OK

//  box test 4
//  自分自身を返すメソッドを使っても OK
trait Ident: Sized {
    fn id(self) -> Self { self }
}
impl Ident for Bar {}

let bar = Box::new(Bar(Foo(0), Foo(1)));
let Bar(foo0, foo1) = bar.id(); //  OK

参照と借用 References and Borrowing

1st/2nd/Jpn

「借用」borrowing 機能により、リソースをコピーすることもその所有権をムーブすることもなく、リソースを用いることが出来る。

型 T の変数 x について、アンパサンド & を用いて &x と記述することで、型 T のリソースを借用する参照型（参照） &T を得る。
- また、更にキーワード mut を用いることで、mutable な変数 x について、&mut x により、mutable な参照型 &mut T を得る。
- あるいは ref / mut ref パターンを用いて参照型を得ることが出来る。
1つの変数から同時に複数の immutable な参照を作ることが出来る。
1つの mutable な変数からは、mutable な参照は同時に 1 つしか作ることが出来ない。
- これを犯すと、コンパイルエラーが生じる。[#E0499]
immutable な参照と mutable な参照は、同時に作ることが出来ない。
- これを犯すと、コンパイルエラーが生じる。[#E0502]
借用されている変数は、参照が 1 つでも生きている間（=生存期間）、変更することが出来ない。
- これを犯すと、コンパイルエラーが生じる。[#E0506]
- このルールにより、immutable な参照の値が不変であることが保証される。
- これにより、借用されているカスタム型について、その成分 element を変更することも出来ない。
以上の性質により mutable な参照は所有権のムーブと似ている。
- 異なるのは mutable な参照がスコープアウトして使えなくなった後、元の変数は通常通りに使用可能であると言うことである。
- つまり、fn do_something(x: Foo) -> Foo のようにしてリソースの明示的な返却を行う（See 所有権を越えて）必要が無く、fn do_something(x: &mut Foo) で済むということである。
変数ではなく、リテラルからも参照を作ることが出来る。
- v1.21.0より、リテラルの参照は、'static なライフタイムを持つ。ライフタイムについては後述。
- ただし何故かリテラルの &mut による mutable な参照は、ローカルスコープのライフタイムを持つ。（これはバグなんじゃなかろうか？）

# ![allow(unused_variables)]

# [derive(Debug, PartialEq)]
struct Foo(i32);

let foo = Foo(123);

{   //  同時に無数の immutable な参照を作成できる.
    let r1: &Foo = &foo;
    let r2 = &foo;
    let ref r3 = foo; // ref パターンによる参照作成
    let r4: &Foo = r3;
    println!("{:?} -> {:?}, {:?}, {:?}, {:?}", foo, r1, r2, r3, r4);
}

let mut bar = Foo(123);

{   //  mutable な参照は同時に 1 つしか作成できない。
    {
        let r1 = &mut bar;
    //  let r2 = &mut bar; // <- Error
        r1.0 += 1;
    }
    {
        let ref mut r3 = bar; // ref mut パターンによる mutable な参照作成
        r3.0 += 1;
    }
    assert_eq!(bar, Foo(125));
}

{   //  immutable な参照と mutable な参照は、同時に作ることが出来ない。
    {
        let r1 = &mut bar;
        //  let r2 = &bar; // <- Error
    }
    {
        let r1 = &bar;
        //  let r2 = &mut bar; // <- Error
    }
}

{   //  借用されている変数は、変更することが出来ない。
    let r1 = &bar;
    //  bar.0 += 1; // <- Error
}

{   //  リテラルの参照は、`'static` のライフタイムを持つ.
    fn check_static(a: &'static Foo) { println!("{:?}", a); }
    
    let r1 = &Foo(1);
    check_static(r1);
    let ref r2 = Foo(2);
    check_static(r2);
    
    let r3 = &mut Foo(3);   // リテラルを `&mut` したものは `'static` なライフタイムを持たない
    //  check_static(r3);   // <- Error 
    let ref mut r4 = Foo(4);
    check_static(r4);
}

参照は参照外し演算子 * により、一時的に参照から実体へと変化する。
- しかし参照の参照外しにより、リソースの所有権をムーブすることは出来ない。
  - これを破ると、コンパイルエラーが生じる。[#E0507]
- 一方で Copy を実装していると、リソースのコピーは可能。
immutable な参照は言うまでもなく、mutable な参照についても、リソースが元の変数へと返却される必要がある。
- そのため、参照はリソースを consume する、もといリソースの破壊的な処理は行えない。
  - これを破ると、コンパイルエラーが生じる。[#E0507]

# ![allow(unused_variables, dead_code)]

//#[derive(Debug, PartialEq)] 
struct Foo(i32);

impl Foo {
    fn not_consume(&self) {}
    fn consume(self) {}
}

let foo = Foo(100);
let val = 23i32;

{   //  参照からリソースをムーブすることは出来ない.
    let f = &foo;
    let g = &val;
    //  let f2 = *f;    // <- Error. ムーブ不可なのでエラー
    let g2 = *g;    // i32 はコピー可なので O.K.
}

{   //  参照からリソースをムーブすることは出来ない.
    let f = &foo;
    f.not_consume();    //  メソッド `consume(self)` は `self` を消費しないので可.
    //  f.consume();    // メソッド `consume(self)` は `self` を消費するので不可.
}

参照型の実体はポインタである。
- そのためキーワード as を用いたキャストにより、ゼロコストで生ポインタへと変換できる。
  - r / mut_r を型 T の immutable / mutable な参照 &T / &mut T として、
    - r as *const T, r_mut as *const T で const ポインタ
    - r_mut as *mut T で mut ポインタ

カスタム型の借用

カスタム型について、その借用の管理は成分 element 単位で行われる。

# ![allow(unused_variables)]

struct Foo(i32);
struct Bar { a: Foo, bc: (Foo, Foo), };

let bar = Bar { a: Foo(1), bc: (Foo(2), Foo(3)) };
{   //  カスタム型の成分をそれぞれ借用することが出来る.
    let b = &bar;
    let ba = &bar.a;
    let bb = &b.bc.0;
}

let mut bar2 = Bar { a: Foo(1), bc: (Foo(2), Foo(3)) };
{
    {   //  借用の管理は成分 element 単位で行われる
        let b_a = &bar2.a;
        let b_a2 = &bar2.a;
        let b_b = &mut bar2.bc.0;
        //  let b_b2 = &mut bar2.bc.0;  //  bar2.bc.0 は既に mutable 借用されているので、更に借用することは不可.
        let b_c = &bar2.bc.1;
        //  let b_c2 = &mut bar2.bc.1;  //  bar2.bc.1 は既に借用されているので、mutable な参照を作ることは不可.
    }
}

ライフタイム

参照型の実体はポインタであるが、所有権システムと同様のシステムにより、ダングリング・ポインタ (dangling pointer) もといダングリング参照 (dangling references) の発生をコンパイラが防いでいる。
- すなわち、参照の生存期間 (lifetime; ライフタイム) を、参照先の変数がリソースを所有している期間より常に短くコンパイラが制限している。
- このことで、参照先の変数がリソースの所有権を失っているというようなこと、リソースが開放済みであるようなことが決して発生しない。

参照値の内部値の取りだし

let optional: Option<Box<i32>> = None;
check_optional(&optional);

let optional: Option<Box<i32>> = Some(Box::new(9000));
check_optional(&optional);

fn check_optional(optional: &Option<Box<i32>>) {
    match *optional {
        Some(ref p) => println!("have value {}", p),
        None => println!("have no value"),
    }
}

参照（借用）は内部値にも浸透するので、そのパターンマッチに際し ref が必要。

`mem::replace`を使って、借用値を`clone()`すること無く書き換える

TL;DR: &mut変数から、値をムーブして得たいことがある。そのためには、目的の値を別の値で置換することで得る。

&mutで得ている変数やその変数の成分を他へムーブすることは出来ない。
- そこでstd::mem::replaceを使って、他の値と交換することで適当な更新を行う。
- See Rustの身代わりパターン - 簡潔なQ, mem::replace to keep owned values in changed enums
mem::replace と mem::swap は、ライフタイムや借用の制約がある Rust プログラミングにおいて多用する、共に重要な関数である。
以下は A.x == 0 のときに B へと変換するコード。
- ナイーブな処理では、借用値の中身をムーブ出来ないとエラーが出る。
- clone()する処理では上手く行くが、クローン分無駄なコストがかさむ。
- そこで mem::replace して目標を空文字列と入れ替えて取り出すと、上手く行く。
  - 空文字列 String::new() だけではヒープ確保は行われないので、余計なコストを増やさずに済む。
- なお、*eへの代入がif let式の外側に出ているのは、if let式の内部ではeが借用されているため、更新できないから。
- ただしこの例は、fn a_to_b(e: MyEnum)と引数をconsumeする関数の方が妥当かもしれない。

use std::mem;

enum MyEnum {
    A { name: String, x: u8 },
    B { name: String }
}

/*
fn a_to_b_naive(e: &mut MyEnum) {
    *e = if let MyEnum::A { ref mut name, x: 0 } = *e {
        MyEnum::B { name: *name }
//                        ^^^^^ cannot move out of borrowed content
    } else { return }
}
*/

fn a_to_b_clone(e: &mut MyEnum) {
    *e = if let MyEnum::A { ref mut name, x: 0 } = *e {
        MyEnum::B { name: name.clone() }
    } else { return }
}

fn a_to_b(e: &mut MyEnum) {
    *e = if let MyEnum::A { ref mut name, x: 0 } = *e {
        MyEnum::B { name: mem::replace(name, String::new()) }
    } else { return }
}

型注釈なしの変数への代入

型注釈の無い変数への代入は、元の型が参照型であっても、新しい変数が参照先のリソースの所有権を奪い取る（ムーブさせる）ので注意。

次のコードは問題なくコンパイルが通る。
- let x: &mut _ = y; の行は let x = y as &mut _; と変えても等価。

fn main()
{
    let y = &mut 2i32;
    {
        let x: &mut _ = y;
        *x = 3;
    }
    println!("{}", y);
}

しかし型注釈を取り除いた次のコードではコンパイルエラーが生じる。
- println!();の行で use of moved value: y.
- これはlet x = y;の行で、xへyの持つ所有権がムーブされるためである。

fn main()
{
    let y = &mut 2i32;
    {
        let x = y;
        *x = 3;
    }
    println!("{}", y);
}

2つのコードでxの型は同一であるのに型注釈の有無で挙動が変わるのは不合理なので、何時か修正されるかも知れない。

実装 `impl`

implキーワードを用いた実装には、以下の2種類がある。

固有実装 - impl AType { ... } の形式。型に関数を関連付ける。
トレイト実装 - impl ATrait for AType { ... } の形式。型にトレイトを実装させる。

固有実装 inherent implementation

関連付ける関数（メソッド）は、以下の2種類に分けられる。
- クラスメソッド（関連関数）
- インスタンスメソッド
固有実装が書けるのは、型の定義されているクレート内部のみ。[#E0116]
- よって、例えば Vec<T> は std クレートで定義されているため、ユーザーが勝手にメソッドを追加することは出来ない。
- 故に、外部クレートの型について固有実装を書きたいときは、1要素タプル構造体などのラッパーを自分で書く必要がある。

メソッド構文 Method Syntax

キーワードselfを用いて、インスタンスメソッド（のようなもの）を定義できる
- 第1引数が &self, &mut self, self のいずれかである
- インスタンスメソッドは、インスタンスに対しドット.を用いたメソッド呼び出しが行える。
  - 例えばインスタンスメソッド fn method(&self, val: i32) は、その型Fooのインスタンスfoo に対し、foo.method(10) で呼び出しが行える。
- ドットを用いない呼び出しも行える。
  - 先の例においては、foo.method(10) == Foo::method(&foo, 10)
- 定義において
  - fn method(&self) { ... } == fn method(self: &Self) { ... }
  - fn method(&mut self) { ... } == fn method(self: &mut Self) { ... }
  - fn method(self) { ... } == fn method(self: Self) { ... }
    - 前者は後者の糖衣構文
- fn method(self)メソッドにおいては、selfは消費 (consume) されてしまうことに留意。
  - というか self を消費（破損）するようなメソッドを、これで記述する。
  - 一方fn method(&self),..(&mut sulf)メソッドにおいては、メソッド呼び出し後にselfは借用から戻ってくる。
それ以外は、クラスメソッド（のようなもの）である
- Self::new() は、よく使われるクラスメソッドの代表例

# [derive(Debug)]
struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}
impl Circle {
    fn new(x: f64, y: f64, radius: f64) -> Self {
        Circle { x: x, y: y, radius: radius, }
    }
}
impl Circle {
    fn reference(&self) {
       println!("taking self by reference!");
    }
    fn mutable_reference(&mut self) {
       println!("taking self by mutable reference!");
    }
    fn takes_ownership(self) {
       println!("taking ownership of self!");
    }
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius * self.radius)
    }
}

let c = Circle::new(0.0, 0.0, 1.0);
c.reference();
println!("{:?}'s area = {}", c, c.area());
println!("{:?}'s area = {}", c, Circle::area(&c));
c.takes_ownership(); // ここで c が消費される
// c.reference(); // よってもう c は使えない

トレイト実装 trait implementation

トレイトの実装においては、関数（メソッド）を実装するだけでなく、以下の関連付けも行う。
- 型（関連型）
- 定数（関連定数）

クロージャ Closures

1st/Ex./Jpn

クロージャはバーティカルバー | で引数を囲むことで記述する
引数、戻り値の型名は省略も明示も可能

let plus_one = |x| x + 1;
let plus_two = |x: i32| { x + 2 };
let plus_three = |x: i32| -> i32 { x + 3 };

assert_eq!(3, plus_one(2));
assert_eq!(3, plus_two(1));
assert_eq!(3, plus_three(0));

クロージャはstd::ops::{Fn, FnOnce, FnMut}トレイトを実装した何かであり、
- クロージャ構文はFn, FnOnce, FnMutトレイト実装の糖衣構文である。
- 単にFn(T) -> Uの実装と言うだけでは様々なサイズの実装があり得るため、サイズ不定であり、下のplus_4の文はエラーとなる。
  - よってBoxで包む必要がある。See クロージャを返す - TRPL-ja
  - See クロージャを boxせずに返したい: Rustのconservative_impl_traitとimplementation leak - 簡潔なQ.

//  let plus_4: Fn(i32) -> i32 = |x| x + 4; Error
//      ^^^^^^ `std::ops::Fn(i32) -> i32` does not have a constant size known at compile-time

let plus_4_box: Box<Fn(i32) -> i32> = Box::new(|x| x + 4); // OK.

assert_eq!(3, plus_4_box(-1));

`move`クロージャ `move` closures

moveキーワードをクロージャ構文の前に置くことで、クロージャに環境の取得を強制する。
クロージャを引数に取るには、型にトレイト std::ops::{Fn, FnMut, FnOnce} を用いる。
- クロージャを引数に取る関数に、関数ポインタを与えることも出来る。

let mut counter = {
    let mut tmp = 0i32;
    move |step: i32| { tmp += step; tmp } // move が無いとライフタイムエラー
};

fn call_with_2<F>(f: &mut F) -> i32
    where F: FnMut(i32) -> i32 {
    f(2)
}

assert_eq!(counter(1), 1);
assert_eq!(call_with_2(&mut counter), 1+2);
assert_eq!(counter(3), 1+2+3);

fn triple_func(v: i32) -> i32 { v * 3 }

assert_eq!(call_with_2(&mut triple_func), 6);

マクロ Macros

foo!()のように、括弧の前・識別子の後に!が付いてるのがマクロ呼び出し。
- マクロ呼び出しには、丸括弧()の他に波括弧{}・角括弧[]を用いることが出来る。
  - foo! {1, 2}, foo!(1, 2); - （foo!がユニット型を返すとき）これら2つはほぼ等価。
  - 波括弧{}の呼び出しでは、マクロの値がユニット()であるとき、区切りのセミコロン;が不要。
    - アイテム的に働くマクロのとき、この波括弧{}呼び出しを使うと分かり易いだろう。
  - test_macro![]; - 何故か角括弧[]でも呼び出せる。

macro_rules! test { () => ( 10 ); }
{
    test!(); 
    test!{}; // <- need ';'
    test![];
}

macro_rules! test { () => ( ; ); }
{
    test!();
    test!{} // <- don't need ';'
    test![];
}

Rust には可変長引数関数が無いので、それらの機能はマクロにより提供される。例：println!, vec!
マクロの引数において、各括弧（丸括弧()・角カッコ[]・波括弧{}）の対応は完全に整合していなければならない。
- この対応により、コンパイラはマクロの展開を後回しすることが出来る。

カスタムマクロ