התאמה של וריאנטים עם נתונים

חלק מהיחידה תכנות מונחה עצמים במסלול ה-Rust של Coddy. שיעור 16 מתוך 61.

בשיעור הקודם השתמשת ב־match בתוך מתודות של enum כדי לטפל בווריאנטים שונים. עכשיו נתמקד באופן שבו match מחלץ בפועל את הנתונים המאוחסנים בתוך הווריאנטים האלה: טכניקה שנקראת פירוק למרכיבים.

כשאתה מבצע התאמה לווריאנט של enum שמכיל נתונים, אתה יכול לקשור את הנתונים למשתנים ישירות בתבנית:

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
    Resize(u32, u32),
}

fn handle_event(event: Event) {
    match event {
        Event::Click { x, y } => {
            println!("Clicked at ({}, {})", x, y);
        }
        Event::KeyPress(key) => {
            println!("Key pressed: {}", key);
        }
        Event::Resize(width, height) => {
            println!("Resized to {}x{}", width, height);
        }
    }
}

כל זרוע מחלצת נתונים באופן שונה, בהתאם למבנה של הווריאנט. עבור וריאנטים דמויי מבנה, משתמשים ב־{ field_name } כדי לחלץ שדות בעלי שמות. עבור וריאנטים דמויי טאפל, משתמשים במשתנים לפי מיקום, כמו (width, height).

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

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

אתגר

קל

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

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

command.rs: הגדר enum ציבורי בשם Command עם שלוש וריאציות:
- Say: מכילה הודעת String יחידה (תחביר של tuple)
- Move: מכילה שדות בעלי שם: direction (String) ו-steps (u32)
- Calculate: מכילה שני ערכי i32 שמייצגים מספרים שיש לחבר (תחביר של tuple)
לאחר מכן, ממש את המתודה execute, שמשתמשת ב-match כדי לפרק כל וריאציה ולהחזיר String שמתארת את הפעולה שבוצעה.
main.rs: הוסף את מודול הפקודות, צור מופע אחד מכל וריאציה של פקודה באמצעות הקלטים שסופקו, וקרא למתודה execute בכל אחת מהן כדי להדפיס את התוצאות.

המתודה execute שלך צריכה לפרק כל וריאציה כדי לגשת לנתונים שלה ולהחזיר הודעות בפורמטים המדויקים הבאים:

עבור Say: Saying: {message}
עבור Move: Moving {steps} steps {direction}
עבור Calculate: {a} + {b} = {sum}

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

Saying: {message}
Moving {steps} steps {direction}
{a} + {b} = {sum}

לדוגמה, עם הודעת אמירה "Hello world", תנועה של 5 צעדים בכיוון "north", וחישוב של 10 ו-25, הפלט יהיה:

Saying: Hello world
Moving 5 steps north
10 + 25 = 35

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

נסו בעצמכם

mod command;

use command::Command;

fn main() {
    // קרא את הקלטים
    let mut say_message = String::new();
    std::io::stdin().read_line(&mut say_message).expect("Failed to read line");
    let say_message = say_message.trim().to_string();

    let mut direction = String::new();
    std::io::stdin().read_line(&mut direction).expect("Failed to read line");
    let direction = direction.trim().to_string();

    let mut steps_input = String::new();
    std::io::stdin().read_line(&mut steps_input).expect("Failed to read line");
    let steps: u32 = steps_input.trim().parse().expect("Failed to parse steps");

    let mut num1_input = String::new();
    std::io::stdin().read_line(&mut num1_input).expect("Failed to read line");
    let num1: i32 = num1_input.trim().parse().expect("Failed to parse num1");

    let mut num2_input = String::new();
    std::io::stdin().read_line(&mut num2_input).expect("Failed to read line");
    let num2: i32 = num2_input.trim().parse().expect("Failed to parse num2");

    // TODO: צור פקודת Say באמצעות say_message והפעל אותה
    
    // TODO: צור פקודת Move באמצעות direction ו-steps, והפעל אותה
    
    // TODO: צור פקודת Calculate באמצעות num1 ו-num2, והפעל אותה
    
    // TODO: הדפס את התוצאות של כל הפעלת פקודה
}