第18章 トレイト.

// メソッド fn speak(&self) -> String を持つトレイトSpeakを定義せよ
trait Speak { 
    fn speak(&self) -> String; 
} 

struct Dog {
    name: String,
}

// DogにSpeakを実装せよ
// speakは「名前「ワン！」」の形の文字列を返すこと
impl Speak for Dog { 
    fn speak(&self) -> String { 
        format!("{}「ワン！」", self.name) 
    } 
} 

fn main() {
    let dog = Dog {
        name: String::from("ポチ"),
    };
    println!("{}", dog.speak());
}

trait Shape {
    fn name(&self) -> String;
    fn area(&self) -> u32;
}

struct Square {
    side: u32,
}

impl Shape for Square {
    fn name(&self) -> String { 
        String::from("正方形") 
    } 

    fn area(&self) -> u32 {
        self.side * self.side
    }
}

fn main() {
    let square = Square { side: 3 };
    println!("{}の面積: {}", square.name(), square.area());
}

trait Describe {
    fn describe(&self) -> String;
}

struct Book {
    title: String,
    price: u32,
}

impl Describe for Book {
    fn describe(&self) -> String {
        format!("書籍『{}』 {}円", self.title, self.price)
    }
}

struct Pen {
    color: String,
    price: u32,
}

// PenにDescribeを実装せよ
// describeは「ボールペン（色） 価格円」の形の文字列を返すこと
impl Describe for Pen { 
    fn describe(&self) -> String { 
        format!("ボールペン（{}） {}円", self.color, self.price) 
    } 
} 

fn main() {
    let book = Book {
        title: String::from("Rust入門"),
        price: 3200,
    };
    let pen = Pen {
        color: String::from("黒"),
        price: 150,
    };
    println!("{}", book.describe());
    println!("{}", pen.describe());
}

trait Greet {
    // 「こんにちは」を返す既定の処理をここに書け
    fn greet(&self) -> String; 
    fn greet(&self) -> String { 
        String::from("こんにちは") 
    } 
}

struct Staff;
struct Customer;

impl Greet for Staff {}
impl Greet for Customer {}

fn main() {
    println!("{}", Staff.greet());
    println!("{}", Customer.greet());
}

trait Greet {
    fn greet(&self) -> String {
        String::from("こんにちは")
    }
}

struct Staff;
struct Robot;

impl Greet for Staff {}

// Robotのgreetは「ピピッ、コンニチハ」を返すようにせよ
impl Greet for Robot {} 
impl Greet for Robot { 
    fn greet(&self) -> String { 
        String::from("ピピッ、コンニチハ") 
    } 
} 

fn main() {
    println!("{}", Staff.greet());
    println!("{}", Robot.greet());
}

trait Score {
    fn points(&self) -> u32;

    fn rank(&self) -> String {
        if self.points() >= 90 {
            String::from("A")
        } else if self.points() >= 70 {
            String::from("B")
        } else if self.points() >= 60 {
            String::from("C")
        } else {
            String::from("D")
        }
    }

    fn passed(&self) -> bool {
        self.points() >= 60
    }

    fn summary(&self) -> String {
        let result = if self.passed() { "合格" } else { "不合格" };
        format!("{}点 → {}（{}）", self.points(), result, self.rank())
    }
}

struct Exam {
    score: u32,
}

struct Quiz {
    correct: u32, // 正答数。1問10点
}

// ExamにScoreを実装せよ（pointsはscoreをそのまま返す）
impl Score for Exam { 
    fn points(&self) -> u32 { 
        self.score 
    } 
} 

// QuizにScoreを実装せよ（pointsは正答数×10を返す）
impl Score for Quiz { 
    fn points(&self) -> u32 { 
        self.correct * 10
    } 
} 

fn main() {
    let exam = Exam { score: 85 };
    let quiz = Quiz { correct: 4 };
    println!("期末試験: {}", exam.summary());
    println!("小テスト: {}", quiz.summary());
}

// トレイトNotifyを定義せよ（recipient・contentは必須、channel・messageはデフォルト実装）
trait Notify { 
    fn recipient(&self) -> String; 
    fn content(&self) -> String; 

    fn channel(&self) -> String { 
        String::from("通知") 
    } 

    fn message(&self) -> String { 
        format!("[{}] {}: {}", self.channel(), self.recipient(), self.content()) 
    } 
} 

struct Email {
    to: String,
    address: String,
    subject: String,
    body: String,
}

struct Sms {
    to: String,
    phone: String,
    text: String,
}

// EmailにNotifyを実装せよ（channelは「メール」に上書き）
impl Notify for Email { 
    fn recipient(&self) -> String { 
        format!("{} <{}>", self.to, self.address) 
    } 

    fn content(&self) -> String { 
        format!("{} / {}", self.subject, self.body) 
    } 

    fn channel(&self) -> String { 
        String::from("メール") 
    } 
} 

// SmsにNotifyを実装せよ（channelはデフォルトのまま）
impl Notify for Sms { 
    fn recipient(&self) -> String { 
        format!("{} ({})", self.to, self.phone) 
    } 

    fn content(&self) -> String { 
        self.text.clone() 
    } 
} 

fn sample_email() -> Email {
    Email {
        to: String::from("太郎"),
        address: String::from("[email protected]"),
        subject: String::from("請求書"),
        body: String::from("今月分を送付しました"),
    }
}

fn sample_sms() -> Sms {
    Sms {
        to: String::from("花子"),
        phone: String::from("090-0000-0000"),
        text: String::from("配達が完了しました"),
    }
}

#[test]
fn test_channel() {
    assert_eq!(sample_email().channel(), "メール");
    assert_eq!(sample_sms().channel(), "通知");
}

#[test]
fn test_recipient_and_content() {
    let email = sample_email();
    assert_eq!(email.recipient(), "太郎 <[email protected]>");
    assert_eq!(email.content(), "請求書 / 今月分を送付しました");

    let sms = sample_sms();
    assert_eq!(sms.recipient(), "花子 (090-0000-0000)");
    assert_eq!(sms.content(), "配達が完了しました");
}

#[test]
fn test_message() {
    assert_eq!(
        sample_email().message(),
        "[メール] 太郎 <[email protected]>: 請求書 / 今月分を送付しました"
    );
    assert_eq!(
        sample_sms().message(),
        "[通知] 花子 (090-0000-0000): 配達が完了しました"
    );
}