Rust 入門: 構文集

fn main() {
    // 整数型と浮動小数点型
    let dog_age: u8 = 3;
    let distance: i64 = -1_000_000; // _ で桁を区切れる
    let weight: f64 = 12.5;

    println!("{dog_age}");   // 出力: 3
    println!("{distance}");  // 出力: -1000000
    println!("{weight}");    // 出力: 12.5

    // 16 進数・8 進数・2 進数・バイトリテラル
    let hex = 0xff;
    let octal = 0o17;
    let binary = 0b1010;
    let byte = b'A';
    println!("{hex} {octal} {binary} {byte}"); // 出力: 255 15 10 65

    // 真偽値と文字
    let is_dog_hungry: bool = true;
    let emoji: char = '🐕';
    println!("{is_dog_hungry}"); // 出力: true
    println!("{emoji}");         // 出力: 🐕

    // ユニット型
    let unit: () = ();
    println!("{unit:?}"); // 出力: ()

    // 型ごとの最大値・最小値
    println!("{}", u8::MAX);  // 出力: 255
    println!("{}", i32::MIN); // 出力: -2147483648

    // オーバーフローの扱いを明示するメソッド
    let max = u8::MAX;
    println!("{:?}", max.checked_add(1));  // 出力: None
    println!("{}", max.wrapping_add(1));   // 出力: 0
    println!("{}", max.saturating_add(1)); // 出力: 255
}

const MAX_DOGS: u32 = 100;
static SHELTER_NAME: &str = "Happy Paws";

fn main() {
    let name = "Buddy";
    // name = "Max"; // エラー[E0384]: cannot assign twice to immutable variable `name`

    let mut age = 3;
    age += 1;
    println!("{name} is {age}"); // 出力: Buddy is 4

    // シャドーイング（同じ名前で新しい変数を宣言する）
    let weight = "12";
    let weight: u32 = weight.parse().unwrap(); // &str から u32 に型が変わる
    println!("{}", weight * 2); // 出力: 24

    println!("{MAX_DOGS}");     // 出力: 100
    println!("{SHELTER_NAME}"); // 出力: Happy Paws
}

fn greet_dog(name: &str) -> String {
    format!("Hello, {name}!")
}

fn main() {
    // 型注釈
    let cat_name: &str = "Whiskers";
    println!("{cat_name}"); // 出力: Whiskers

    // 型推論
    let lion_age = 5;   // i32 と推論される
    let weight = 190.5; // f64 と推論される
    println!("{lion_age} {weight}"); // 出力: 5 190.5

    // 後の使われ方から推論される
    let mut animals = Vec::new(); // この時点では要素の型が決まっていない
    animals.push("Dog");          // Vec<&str> と推論される
    println!("{animals:?}");      // 出力: ["Dog"]

    // 推論できない場合は型注釈かターボフィッシュ (::<>) が必要
    let count: u32 = "42".parse().unwrap();
    let total = "8".parse::<u32>().unwrap();
    println!("{}", count + total); // 出力: 50

    println!("{}", greet_dog("Buddy")); // 出力: Hello, Buddy!
    // greet_dog(123); // エラー[E0308]: mismatched types
}

fn main() {
    // as によるプリミティブ型のキャスト
    let age: i32 = 300;
    println!("{}", age as f64 / 2.0); // 出力: 150
    println!("{}", age as u8);        // 出力: 44
    // u8 に収まらない値は上位ビットが切り捨てられる (300 - 256 = 44)
    println!("{}", 3.99_f64 as i32);  // 出力: 3

    // From / Into（失敗しない変換）
    let small: u8 = 42;
    let big: u64 = u64::from(small);
    let bigger: i128 = small.into();
    println!("{big} {bigger}"); // 出力: 42 42

    // TryFrom / TryInto（失敗しうる変換）
    let result = u8::try_from(300_i32);
    println!("{result:?}"); // 出力: Err(TryFromIntError(PosOverflow))
    let ok: Result<u8, _> = 200_i32.try_into();
    println!("{ok:?}"); // 出力: Ok(200)

    // 文字列との相互変換
    let n: i32 = "123".parse().unwrap();
    let s = n.to_string();
    println!("{} {}", n + 1, s + "!"); // 出力: 124 123!
}

type DogId = u32;
type Kennel = Vec<(DogId, String)>;
type Callback = Box<dyn Fn(&str) -> String>;

fn main() {
    let kennel: Kennel = vec![(1, String::from("Buddy")), (2, String::from("Max"))];
    println!("{:?}", kennel[1]); // 出力: (2, "Max")

    let greet: Callback = Box::new(|name| format!("Hello, {name}!"));
    println!("{}", greet("Luna")); // 出力: Hello, Luna!

    // 別名なので元の型と互換性がある
    let id: DogId = 5;
    let raw: u32 = id;
    println!("{raw}"); // 出力: 5
}

fn main() {
    // タプル
    let pet: (&str, u8, bool) = ("Buddy", 3, true);
    println!("{}", pet.0); // 出力: Buddy
    let (name, age, vaccinated) = pet; // 分解
    println!("{name} {age} {vaccinated}"); // 出力: Buddy 3 true

    // 配列（固定長・同じ型）
    let animals: [&str; 3] = ["Dog", "Cat", "Bird"];
    let zeros = [0; 5]; // 0 を 5 個並べる
    println!("{}", animals[0]);    // 出力: Dog
    println!("{}", animals.len()); // 出力: 3
    println!("{zeros:?}");         // 出力: [0, 0, 0, 0, 0]

    // スライス（配列や Vec の一部への参照）
    let ages = [3, 5, 2, 8];
    let middle: &[i32] = &ages[1..3];
    println!("{middle:?}"); // 出力: [5, 2]
}

fn main() {
    // &str: 文字列スライス（借用）
    let greeting: &str = "Hello";

    // String: ヒープ上の可変な文字列（所有）
    let mut name = String::from("Bud");
    name.push_str("dy");
    name.push('!');
    println!("{name}"); // 出力: Buddy!

    // 連結
    let message = format!("{greeting}, {name}");
    println!("{message}"); // 出力: Hello, Buddy!
    let joined = String::from("Dog") + "-" + "Cat";
    println!("{joined}"); // 出力: Dog-Cat

    // String から &str へは & で借用できる
    let slice: &str = &name;
    println!("{}", slice.len()); // 出力: 6

    // UTF-8 なので文字数とバイト数は一致しない
    let japanese = "こんにちは";
    println!("{}", japanese.len());           // 出力: 15
    println!("{}", japanese.chars().count()); // 出力: 5
    println!("{}", &japanese[0..3]);          // 出力: こ
    // &japanese[0..1]; // panic: 文字の境界ではない

    // よく使うメソッド
    println!("{}", "  Max  ".trim());               // 出力: Max
    println!("{}", "dog".to_uppercase());           // 出力: DOG
    println!("{}", "Buddy".contains("dd"));         // 出力: true
    println!("{}", "cat".replace('c', "b"));        // 出力: bat
    println!("{:?}", "a,b,c".split(',').collect::<Vec<_>>()); // 出力: ["a", "b", "c"]

    // 生文字列リテラル（エスケープしない）
    let path = r"C:\animals\dog.txt";
    println!("{path}"); // 出力: C:\animals\dog.txt

    // 書式指定
    let pi = 3.14159;
    println!("{pi:.2}");        // 出力: 3.14
    println!("[{:>6}]", "Dog"); // 出力: [   Dog]
    println!("[{:<6}]", "Dog"); // 出力: [Dog   ]
    println!("{:05}", 42);      // 出力: 00042
    println!("{:#x}", 255);     // 出力: 0xff
}

#[derive(Debug)]
struct Dog {
    name: String,
    age: u8,
    breed: String,
}

// タプル構造体
struct Point(i32, i32);

// ユニット構造体
struct Marker;

fn main() {
    let name = String::from("Max");
    let dog = Dog {
        name, // フィールド名と変数名が同じなら省略できる
        age: 4,
        breed: String::from("Golden Retriever"),
    };
    println!("{} is {}", dog.name, dog.age); // 出力: Max is 4

    // 構造体更新記法（breed は dog からムーブされる）
    let puppy = Dog {
        name: String::from("Charlie"),
        age: 1,
        ..dog
    };
    println!("{puppy:?}"); // 出力: Dog { name: "Charlie", age: 1, breed: "Golden Retriever" }

    // 変更するにはインスタンス全体を mut にする
    let mut luna = Dog {
        name: String::from("Luna"),
        age: 2,
        breed: String::from("Shiba"),
    };
    luna.age += 1;
    println!("{} {}", luna.age, luna.breed); // 出力: 3 Shiba

    let p = Point(10, 20);
    println!("{} {}", p.0, p.1); // 出力: 10 20

    let _marker = Marker;
}

// データを持たない列挙型
#[derive(Debug)]
enum Direction {
    North,
    South,
    East,
    West,
}

// 判別値を指定した列挙型
enum HttpStatus {
    Ok = 200,
    NotFound = 404,
    InternalServerError = 500,
}

// バリアントごとに異なるデータを持つ列挙型
enum Shape {
    Circle { radius: f64 },
    Square(f64),
    Rectangle { width: f64, height: f64 },
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
            Shape::Square(side) => side * side,
            Shape::Rectangle { width, height } => width * height,
        }
    }
}

fn main() {
    let directions = [Direction::North, Direction::South, Direction::East, Direction::West];
    println!("{directions:?}"); // 出力: [North, South, East, West]

    println!(
        "{} {} {}",
        HttpStatus::Ok as i32,
        HttpStatus::NotFound as i32,
        HttpStatus::InternalServerError as i32
    ); // 出力: 200 404 500

    let shapes = [
        Shape::Circle { radius: 10.0 },
        Shape::Square(5.0),
        Shape::Rectangle { width: 10.0, height: 20.0 },
    ];
    for shape in &shapes {
        println!("{:.2}", shape.area());
    }
    // 出力: 314.16
    // 出力: 25.00
    // 出力: 200.00
}

fn find_dog(id: u32) -> Option<&'static str> {
    match id {
        1 => Some("Buddy"),
        2 => Some("Max"),
        _ => None,
    }
}

fn parse_age(input: &str) -> Result<u8, String> {
    input.parse::<u8>().map_err(|e| format!("invalid age: {e}"))
}

fn main() {
    // Option<T>: 値がある (Some) か、ない (None)
    println!("{:?}", find_dog(1)); // 出力: Some("Buddy")
    println!("{:?}", find_dog(9)); // 出力: None

    // 値の取り出し
    println!("{}", find_dog(9).unwrap_or("Unknown"));     // 出力: Unknown
    println!("{:?}", find_dog(2).map(|name| name.len())); // 出力: Some(3)

    if let Some(name) = find_dog(1) {
        println!("Found {name}"); // 出力: Found Buddy
    }

    // Result<T, E>: 成功 (Ok) か、失敗 (Err)
    println!("{:?}", parse_age("3"));   // 出力: Ok(3)
    println!("{:?}", parse_age("abc")); // 出力: Err("invalid age: invalid digit found in string")

    match parse_age("300") {
        Ok(age) => println!("Age: {age}"),
        Err(e) => println!("Error: {e}"), // 出力: Error: invalid age: number too large to fit in target type
    }

    // Option と Result の相互変換
    let as_result: Result<&str, &str> = find_dog(9).ok_or("not found");
    println!("{as_result:?}"); // 出力: Err("not found")
    let as_option: Option<u8> = parse_age("5").ok();
    println!("{as_option:?}"); // 出力: Some(5)
}

fn main() {
    // if は式なので値を返せる
    let age = 3;
    let stage = if age < 1 { "puppy" } else if age < 8 { "adult" } else { "senior" };
    println!("{stage}"); // 出力: adult

    // loop は break で値を返せる
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 10;
        }
    };
    println!("{result}"); // 出力: 50

    // while
    let mut treats = 3;
    while treats > 0 {
        treats -= 1;
    }
    println!("{treats}"); // 出力: 0

    // for と範囲
    let mut sum = 0;
    for i in 1..=5 {
        sum += i;
    }
    println!("{sum}"); // 出力: 15

    // インデックス付きで反復する
    let animals = ["Dog", "Cat", "Bird"];
    for (i, animal) in animals.iter().enumerate() {
        println!("{i}: {animal}");
    }
    // 出力: 0: Dog
    // 出力: 1: Cat
    // 出力: 2: Bird

    // ラベル付きループ
    'outer: for x in 0..5 {
        for y in 0..5 {
            if x + y == 6 {
                println!("{x} + {y}"); // 出力: 2 + 4
                break 'outer;
            }
        }
    }

    // while let: パターンに一致する間繰り返す
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("{top}");
    }
    // 出力: 3
    // 出力: 2
    // 出力: 1
}

struct Dog {
    name: String,
    age: u8,
}

fn describe(age: u8) -> &'static str {
    match age {
        0 => "newborn",
        1 | 2 => "puppy",
        3..=7 => "adult",
        _ => "senior",
    }
}

fn main() {
    println!("{}", describe(0));  // 出力: newborn
    println!("{}", describe(2));  // 出力: puppy
    println!("{}", describe(10)); // 出力: senior

    // ガードと @ バインディング
    let weight = 35;
    let size = match weight {
        w @ 0..=10 => format!("small ({w}kg)"),
        w if w > 30 => format!("large ({w}kg)"),
        w => format!("medium ({w}kg)"),
    };
    println!("{size}"); // 出力: large (35kg)

    // タプルの分解
    let point = (0, 7);
    match point {
        (0, y) => println!("on the y axis at {y}"), // 出力: on the y axis at 7
        (x, 0) => println!("on the x axis at {x}"),
        _ => println!("elsewhere"),
    }

    // 構造体の分解
    let dog = Dog { name: String::from("Buddy"), age: 3 };
    let Dog { name, age } = &dog;
    println!("{name} {age}"); // 出力: Buddy 3

    match &dog {
        Dog { age: 0..=1, .. } => println!("young"),
        Dog { name, .. } => println!("{name} is grown up"), // 出力: Buddy is grown up
    }

    // スライスパターン
    let animals = ["Dog", "Cat", "Bird", "Fish"];
    match &animals[..] {
        [] => println!("empty"),
        [only] => println!("only {only}"),
        [first, .., last] => println!("{first} ... {last}"), // 出力: Dog ... Fish
    }

    // matches! マクロ
    println!("{}", matches!(describe(5), "adult" | "senior")); // 出力: true
}

fn parse_pair(input: &str) -> Option<(String, u8)> {
    // let else: パターンに一致しなければ else で早期リターン
    let Some((name, age)) = input.split_once(':') else {
        return None;
    };
    let Ok(age) = age.parse::<u8>() else {
        return None;
    };
    Some((name.to_string(), age))
}

fn main() {
    // if let: 1 つのパターンだけ扱う
    let favorite: Option<&str> = Some("Buddy");
    if let Some(name) = favorite {
        println!("Favorite: {name}"); // 出力: Favorite: Buddy
    } else {
        println!("No favorite");
    }

    println!("{:?}", parse_pair("Max:4")); // 出力: Some(("Max", 4))
    println!("{:?}", parse_pair("Max"));   // 出力: None

    // let チェーン（Rust 1.88 以降、Edition 2024）
    let input = "Luna:2";
    if let Some((name, age)) = parse_pair(input)
        && age < 3
        && let Some(initial) = name.chars().next()
    {
        println!("{name} ({initial}) is a puppy"); // 出力: Luna (L) is a puppy
    }

    // if let ガード（Rust 1.95 以降）
    let entries = ["Buddy:5", "unknown", "Kitty:x"];
    for entry in entries {
        match entry {
            e if let Some((name, age)) = parse_pair(e) => println!("{name}: {age}"),
            e if e.contains(':') => println!("broken: {e}"),
            e => println!("skipped: {e}"),
        }
    }
    // 出力: Buddy: 5
    // 出力: skipped: unknown
    // 出力: broken: Kitty:x
}

fn take_ownership(name: String) {
    println!("{name} was adopted");
}

fn main() {
    // ムーブ: 所有権が移動する
    let dog = String::from("Buddy");
    let adopted = dog;
    // println!("{dog}"); // エラー[E0382]: borrow of moved value: `dog`
    println!("{adopted}"); // 出力: Buddy

    // 関数に渡してもムーブする
    let cat = String::from("Whiskers");
    take_ownership(cat); // 出力: Whiskers was adopted
    // println!("{cat}"); // エラー[E0382]: borrow of moved value: `cat`

    // clone: 値を複製する（ヒープ上のデータもコピーされる）
    let bird = String::from("Tweety");
    let bird_copy = bird.clone();
    println!("{bird} {bird_copy}"); // 出力: Tweety Tweety

    // Copy トレイトを実装する型はコピーされる
    let age = 3;
    let age_copy = age;
    println!("{age} {age_copy}"); // 出力: 3 3

    // スコープを抜けると値は破棄 (drop) される
    {
        let temp = String::from("temporary");
        println!("{temp}"); // 出力: temporary
    } // ここで temp が drop される
}

fn name_length(name: &str) -> usize {
    name.len()
}

fn add_suffix(name: &mut String) {
    name.push_str(" Jr.");
}

fn main() {
    let mut name = String::from("Buddy");

    // 不変参照: 所有権を移さずに値を読む（&String は &str に自動変換される）
    let len = name_length(&name);
    println!("{name} {len}"); // 出力: Buddy 5

    // 可変参照: 所有権を移さずに値を変更する
    add_suffix(&mut name);
    println!("{name}"); // 出力: Buddy Jr.

    // 不変参照は同時にいくつでも作れる
    let r1 = &name;
    let r2 = &name;
    println!("{r1} / {r2}"); // 出力: Buddy Jr. / Buddy Jr.

    // 可変参照は同時に 1 つだけ。不変参照とも共存できない
    let r3 = &mut name;
    // let r4 = &name; // エラー[E0502]: cannot borrow `name` as immutable because it is also borrowed as mutable
    r3.push('!');
    println!("{r3}"); // 出力: Buddy Jr.!

    // * で参照外しして値を変更する
    let mut count = 10;
    let c = &mut count;
    *c += 1;
    println!("{count}"); // 出力: 11
}

// 戻り値の参照が 2 つの引数と同じ期間だけ有効であることを 'a で示す
fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}

// 参照をフィールドに持つ構造体にはライフタイム注釈が必要
struct DogTag<'a> {
    name: &'a str,
}

impl DogTag<'_> {
    // 省略規則により戻り値は &self と同じライフタイムになる
    fn name(&self) -> &str {
        self.name
    }
}

fn main() {
    println!("{}", longer("Buddy", "Max")); // 出力: Buddy

    let owner = String::from("Charlie");
    let tag = DogTag { name: &owner };
    println!("{}", tag.name()); // 出力: Charlie

    // 'static: プログラムの終了まで有効な参照
    let s: &'static str = "I live forever";
    println!("{s}"); // 出力: I live forever

    // ぶら下がり参照はコンパイルエラーになる
    // let r;
    // {
    //     let x = 5;
    //     r = &x; // エラー[E0597]: `x` does not live long enough
    // }
    // println!("{r}");
}

// 最後の式（セミコロンなし）が戻り値になる
fn calculate_speed(distance: f64, time: f64) -> f64 {
    distance / time
}

// return で早期リターン
fn check_age(age: i32) -> &'static str {
    if age < 0 {
        return "invalid";
    }
    "valid"
}

// 戻り値がない関数は () を返す
fn feed(name: &str) {
    println!("Feeding {name}");
}

// 複数の値はタプルで返す
fn min_max(values: &[i32]) -> (i32, i32) {
    let min = *values.iter().min().unwrap();
    let max = *values.iter().max().unwrap();
    (min, max)
}

// デフォルト引数の代わりに Option を使う
fn describe_pet(name: &str, breed: Option<&str>) -> String {
    match breed {
        Some(b) => format!("{name} is a {b}"),
        None => format!("{name} is a mixed breed"),
    }
}

// ! (never 型): 決して戻らない関数
fn fail(message: &str) -> ! {
    panic!("{message}");
}

fn main() {
    println!("{}", calculate_speed(100.0, 10.0)); // 出力: 10
    println!("{}", check_age(-1));                // 出力: invalid
    feed("Buddy");                                // 出力: Feeding Buddy

    let (min, max) = min_max(&[3, 7, 1, 9]);
    println!("{min} {max}"); // 出力: 1 9

    println!("{}", describe_pet("Buddy", Some("Labrador"))); // 出力: Buddy is a Labrador
    println!("{}", describe_pet("Max", None));               // 出力: Max is a mixed breed

    let ready = true;
    if !ready {
        fail("not ready");
    }
}

fn apply<F: Fn(i32) -> i32>(f: F, value: i32) -> i32 {
    f(value)
}

fn make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

fn main() {
    // 基本的なクロージャ
    let add_one = |x: i32| x + 1;
    let square = |x| x * x; // 型は推論される
    println!("{}", add_one(5)); // 出力: 6
    println!("{}", square(4));  // 出力: 16

    // 環境の変数を不変借用でキャプチャする（Fn）
    let bonus = 10;
    let add_bonus = |x| x + bonus;
    println!("{}", apply(add_bonus, 5)); // 出力: 15

    // 可変借用でキャプチャする（FnMut）
    let mut counter = 0;
    let mut increment = || counter += 1;
    increment();
    increment();
    println!("{counter}"); // 出力: 2

    // 所有権を奪うクロージャ（FnOnce）
    let name = String::from("Buddy");
    let consume = move || name;
    let taken = consume();
    // consume(); // エラー[E0382]: use of moved value: `consume`
    println!("{taken}"); // 出力: Buddy

    // クロージャを返す
    let triple = make_multiplier(3);
    println!("{}", triple(7)); // 出力: 21

    // 関数ポインタ（キャプチャしないクロージャは fn 型に変換できる）
    let op: fn(i32) -> i32 = |x| x - 1;
    println!("{}", apply(op, 10)); // 出力: 9
}

#[derive(Debug)]
struct Dog {
    name: String,
    age: u8,
}

impl Dog {
    // 関連定数
    const MAX_AGE: u8 = 30;

    // 関連関数（コンストラクタとして使うのが慣習）
    fn new(name: &str, age: u8) -> Self {
        Self { name: name.to_string(), age }
    }

    // &self: 不変借用で受け取るメソッド
    fn bark(&self) -> String {
        format!("{} says: Woof!", self.name)
    }

    // &mut self: 可変借用で受け取るメソッド
    fn birthday(&mut self) {
        self.age += 1;
    }

    // self: 所有権を受け取るメソッド
    fn into_name(self) -> String {
        self.name
    }
}

fn main() {
    let mut dog = Dog::new("Buddy", 3);
    println!("{}", dog.bark()); // 出力: Buddy says: Woof!

    dog.birthday();
    println!("{dog:?}"); // 出力: Dog { name: "Buddy", age: 4 }
    println!("{}", Dog::MAX_AGE); // 出力: 30

    let name = dog.into_name();
    // dog.bark(); // エラー[E0382]: borrow of moved value: `dog`
    println!("{name}"); // 出力: Buddy
}

trait Animal {
    // 実装必須のメソッド
    fn name(&self) -> String;
    fn sound(&self) -> String;

    // デフォルト実装を持つメソッド
    fn speak(&self) -> String {
        format!("{} says {}", self.name(), self.sound())
    }
}

struct Dog {
    name: String,
}

struct Cat {
    name: String,
}

impl Animal for Dog {
    fn name(&self) -> String {
        self.name.clone()
    }
    fn sound(&self) -> String {
        String::from("Woof!")
    }
}

impl Animal for Cat {
    fn name(&self) -> String {
        self.name.clone()
    }
    fn sound(&self) -> String {
        String::from("Meow!")
    }
    // デフォルト実装を上書きする
    fn speak(&self) -> String {
        format!("{} ignores you", self.name)
    }
}

// 既存の型に自分のトレイトを実装する
trait Describe {
    fn describe(&self) -> String;
}

impl Describe for i32 {
    fn describe(&self) -> String {
        format!("number {self}")
    }
}

fn main() {
    let dog = Dog { name: String::from("Buddy") };
    let cat = Cat { name: String::from("Whiskers") };
    println!("{}", dog.speak()); // 出力: Buddy says Woof!
    println!("{}", cat.speak()); // 出力: Whiskers ignores you
    println!("{}", 42.describe()); // 出力: number 42
}