Unitとtrait implによる抽象化

let unit: () = ();

// 0要素のタプル = Unit 型
let also_unit: () = ();

// C: void は「型ではない」特殊な存在
void foo();           // OK
void* ptr;            // OK（型ではないが汎用ポインタとして使える）
// void x;            // NG: void 型の変数は作れない
// sizeof(void);      // 未定義動作（GCC 拡張では 1）

// Rust: () は普通の型
fn foo() -> () { () }   // OK
let x: () = ();          // OK: Unit 型の変数を作れる
std::mem::size_of::<()>() // 0（サイズゼロだが，正当な型）

// Vec<()> すら作れる
let v: Vec<()> = vec![(), (), ()];
assert_eq!(v.len(), 3);

// Result<(), Error>: 成功時に値がない操作
fn delete_file(path: &str) -> Result<(), std::io::Error> {
    std::fs::remove_file(path)
}

// HashMap<String, ()>: 値がない → 実質的に HashSet と同等
use std::collections::HashMap;
let mut set: HashMap<String, ()> = HashMap::new();
set.insert("key".to_string(), ());

// Option<()>: 「存在するかどうか」だけを表現
let exists: Option<()> = Some(());

// () に対して Display を実装することもできる（実際に標準ライブラリで実装済み）
// () は Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default を実装している

let a: () = Default::default();  // () のデフォルト値は ()
assert_eq!((), ());               // PartialEq が使える

trait Greet {
    fn greet(&self) -> String;
}

struct User {
    name: String,
}

impl Greet for User {
    fn greet(&self) -> String {
        format!("Hello, I'm {}!", self.name)
    }
}

struct Bot {
    id: u32,
}

impl Greet for Bot {
    fn greet(&self) -> String {
        format!("Beep boop, I'm Bot #{}.", self.id)
    }
}

use std::fmt;

struct Point {
    x: f64,
    y: f64,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 1.0, y: 2.0 };
    println!("{}", p);  // (1.0, 2.0)

    // Display を実装すると .to_string() も自動的に使える
    let s: String = p.to_string();
}

struct FileHandle {
    name: String,
}

impl Drop for FileHandle {
    fn drop(&mut self) {
        println!("Closing file: {}", self.name);
    }
}

fn main() {
    let _f = FileHandle { name: String::from("data.txt") };
    println!("File opened");
    // ← ここで _f がスコープを抜け，drop が自動的に呼ばれる
}
// 出力:
// File opened
// Closing file: data.txt

// Copy: 暗黙的なビット単位のコピー
// 値の代入や関数への受け渡し時に自動的にコピーされる
#[derive(Copy, Clone)]
struct Point {
    x: f64,
    y: f64,
}

// Clone: 明示的な深いコピー
// .clone() メソッドの呼び出しが必要
#[derive(Clone)]
struct Buffer {
    data: Vec<u8>,
}

#[derive(PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

fn main() {
    let a = Point { x: 1.0, y: 2.0 };
    let b = Point { x: 1.0, y: 2.0 };
    assert!(a == b);  // PartialEq が == 演算子を提供する
}

use std::ops::Add;

#[derive(Debug, Clone, Copy)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Add for Vec2 {
    type Output = Vec2;

    fn add(self, rhs: Vec2) -> Vec2 {
        Vec2 {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
        }
    }
}

fn main() {
    let a = Vec2 { x: 1.0, y: 2.0 };
    let b = Vec2 { x: 3.0, y: 4.0 };
    let c = a + b;  // Add トレイトの add メソッドが呼ばれる
    println!("{:?}", c); // Vec2 { x: 4.0, y: 6.0 }
}

fn print_all(items: &[impl std::fmt::Display]) {
    for item in items {
        println!("{}", item);
    }
}

trait Summary {
    fn title(&self) -> String;

    // デフォルト実装: オーバーライド可能
    fn summarize(&self) -> String {
        format!("{} - (Read more...)", self.title())
    }
}

struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn title(&self) -> String {
        self.title.clone()
    }
    // summarize はデフォルト実装がそのまま使われる
}

// OK: 自分の型に外部トレイトを実装
impl fmt::Display for MyType { ... }

// OK: 自分のトレイトを外部型に実装
impl MyTrait for Vec<i32> { ... }

// NG: 外部トレイトを外部型に実装
// impl fmt::Display for Vec<i32> { ... }  // コンパイルエラー