טיפוס ברווז ב-Go

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 42 מתוך 107.

המונח טיפוס ברווז מקורו באמרה: "אם הוא הולך כמו ברווז ומגעגע כמו ברווז, אז הוא ברווז." ב-Go, פירוש הדבר שטיפוס לא צריך להצהיר במפורש שהוא מממש ממשק. הוא רק צריך לכלול את המתודות המתאימות.

נבחן את הממשק הזה ואת שני הטיפוסים שאינם קשורים זה לזה כלל:

type Quacker interface {
    Quack() string
}

type Duck struct{}
func (d Duck) Quack() string { return "Quack!" }

type Robot struct{}
func (r Robot) Quack() string { return "Beep-quack!" }

לא Duck ולא Robot מזכירים את Quacker בשום מקום בהגדרות שלהם. ובכל זאת, שניהם מממשים את הממשק פשוט משום שיש להם מתודת Quack() עם החתימה הנכונה:

func MakeItQuack(q Quacker) {
    fmt.Println(q.Quack())
}

func main() {
    MakeItQuack(Duck{})   // קוואק!
    MakeItQuack(Robot{})  // ביפ-קוואק!
}

ההתאמה המרומזת הזו עוצמתית, כי היא מאפשרת לך להגדיר ממשקים לאחר שהטיפוסים כבר קיימים. אפשר ליצור ממשק שתואם לטיפוסים מחבילות חיצוניות בלי לשנות את קוד המקור שלהן. הטיפוסים לא צריכים לדעת על הממשק שלך. הם רק צריכים להתנהג כראוי.

טיפוס ברווזי ב-Go מעניק לך את הגמישות של שפות דינמיות, תוך שמירה על בטיחות טיפוסים בזמן הקומפילציה. המהדר מוודא שלטיפוסים יש בפועל את המתודות הנדרשות לפני שהוא מאפשר להשתמש בהם כערכי ממשק.

אתגר

קל

בואו נבנה מערכת להעברת הודעות שמדגימה טיפוסיות ברווזית בפעולה. תיצרו טיפוסים שאינם קשורים זה לזה, שכולם יכולים לשלוח הודעות דרך ממשק משותף, בלי שאף אחד מהם יצהיר במפורש שהוא מממש אותו.

תארגנו את הקוד שלכם בשלושה קבצים:

messengers.go: צרו שלוש מבנים שאינם קשורים זה לזה, אך במקרה חולקים אותה התנהגות:
- Phone עם שדה Number. המתודה SendMessage(text string) string שלו מחזירה SMS to [Number]: [text]
- Computer עם שדה Email. המתודה SendMessage(text string) string שלו מחזירה Email to [Email]: [text]
- Pigeon עם שדה Name. המתודה SendMessage(text string) string שלו מחזירה [Name] carries: [text]
שימו לב שאף אחד מהטיפוסים האלה לא מזכיר ממשק כלשהו. במקרה פשוט יש להם אותה חתימת מתודה.
sender.go: הגדירו ממשק Messenger שדורש מתודה SendMessage(text string) string. צרו פונקציה בשם Broadcast שמקבלת פרוסה של Messenger ומחרוזת הודעה, ואז מחזירה פרוסת מחרוזות שמכילה את התוצאה של קריאה ל-SendMessage בכל שליח.
main.go: קראו את הפרטים מהקלט, צרו אחד מכל סוג של שליח, אספו אותם לפרוסה של Messenger, והשתמשו ב-Broadcast כדי לשלוח הודעה דרך כולם. הדפיסו כל תוצאה בשורה נפרדת.

הקלטים הבאים יסופקו:

שורה 1: מספר טלפון
שורה 2: כתובת דוא"ל
שורה 3: שם היונה
שורה 4: הודעה להפצה

לדוגמה, בהינתן 555-1234, alice@mail.com, Winston ו-Hello World, הפלט שלכם צריך להיות:

SMS to 555-1234: Hello World
Email to alice@mail.com: Hello World
Winston carries: Hello World

התובנה המרכזית כאן היא של-Phone, ל-Computer ול-Pigeon אין שום דבר משותף. הם לא חולקים טיפוס בסיס ואינם מממשים במפורש את Messenger. ובכל זאת, מכיוון שכולם "געגעים" באותו אופן (יש להם מתודה תואמת), Go מאפשרת להשתמש בכולם כערכי Messenger. זו טיפוסיות ברווזית בפעולה.

נסו בעצמכם

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// קרא מספר טלפון
	scanner.Scan()
	phoneNumber := scanner.Text()
	
	// קרא כתובת דוא״ל
	scanner.Scan()
	email := scanner.Text()
	
	// קרא את שם היונה
	scanner.Scan()
	pigeonName := scanner.Text()
	
	// קרא את ההודעה לשידור
	scanner.Scan()
	message := scanner.Text()
	
	// TODO: צור מופע אחד מכל סוג של שליח (Phone, Computer, Pigeon)
	
	// TODO: אסוף את כל השליחים ל-slice של Messenger
	
	// TODO: השתמש ב-Broadcast כדי לשלוח את ההודעה דרך כל השליחים
	
	// TODO: הדפס כל תוצאה בשורה משלה
	
	// מציין מקום לשימוש במשתנים (יש להסיר בעת המימוש)
	_ = phoneNumber
	_ = email
	_ = pigeonName
	_ = message
}