サンプルコードで身につける: 関連型 — トレイトに型を持たせる

trait Holder {
    type Value; // 実装側が決める「型の置き場所」
    fn get(&self) -> &Self::Value;
}
struct NameHolder {
    name: String,
}
impl Holder for NameHolder {
    type Value = String; // この実装では Value = String と決める
    fn get(&self) -> &String {
        &self.name
    }
}
fn main() {
    let holder = NameHolder { name: String::from("アリス") };
    println!("値 = {}", holder.get());
}

trait Sensor {
    type Reading;
    fn read(&self) -> Self::Reading;
}
struct Thermometer;
struct DoorSensor;
impl Sensor for Thermometer {
    type Reading = f64; // 温度計の読み値は f64
    fn read(&self) -> f64 { 22.5 }
}
impl Sensor for DoorSensor {
    type Reading = bool; // ドアセンサーの読み値は bool
    fn read(&self) -> bool { true }
}
fn main() {
    println!("温度 = {}", Thermometer.read());
    println!("ドアが開いている = {}", DoorSensor.read());
}

trait Stack {
    type Item;
    fn push_item(&mut self, item: Self::Item); // 引数に Self::Item
    fn pop_item(&mut self) -> Option<Self::Item>; // 戻り値にも同じ型
}
struct History {
    pages: Vec<String>,
}
impl Stack for History {
    type Item = String;
    fn push_item(&mut self, item: String) { self.pages.push(item); }
    fn pop_item(&mut self) -> Option<String> { self.pages.pop() }
}
fn main() {
    let mut history = History { pages: Vec::new() };
    history.push_item(String::from("トップ"));
    history.push_item(String::from("設定"));
    println!("戻る: {:?}", history.pop_item());
    println!("戻る: {:?}", history.pop_item());
}

struct Countdown {
    current: u32,
}
impl Iterator for Countdown {
    type Item = u32; // このイテレータが返す型は u32 と一意に決まる
    fn next(&mut self) -> Option<u32> {
        if self.current == 0 {
            return None;
        }
        let value = self.current;
        self.current -= 1;
        Some(value)
    }
}
fn main() {
    let countdown = Countdown { current: 3 };
    for n in countdown { // Iterator を実装したので for で回せる
        println!("{}!", n);
    }
}

trait Parser {
    type Output; // このパーサーが何を返すかを表す型
    fn parse(&self, input: &str) -> Option<Self::Output>;
}
struct NumberParser;
struct CsvParser;
impl Parser for NumberParser {
    type Output = i32;
    fn parse(&self, input: &str) -> Option<i32> { input.trim().parse().ok() }
}
impl Parser for CsvParser {
    type Output = Vec<String>;
    fn parse(&self, input: &str) -> Option<Vec<String>> {
        Some(input.split(',').map(|s| s.trim().to_string()).collect())
    }
}
fn main() {
    println!("{:?}", NumberParser.parse(" 42 "));
    println!("{:?}", CsvParser.parse("a, b, c"));
}