Traits עם פרמטרים

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

עד כה, מתודות ה־trait שלנו קיבלו רק את &self כפרמטר. אבל מתודות trait יכולות לקבל פרמטרים נוספים, בדיוק כמו מתודות רגילות. כך הן נעשות שימושיות הרבה יותר לפעולות בעולם האמיתי.

בעת הגדרת trait, אפשר לכלול את כל הפרמטרים הדרושים לך בחתימות המתודות:

trait Calculator {
    fn add(&self, a: i32, b: i32) -> i32;
    fn multiply(&self, a: i32, b: i32) -> i32;
}

ה-trait‏ Calculator הזה דורש שתי מתודות, שכל אחת מהן מקבלת שני מספרים שלמים בנוסף ל-&self. כל טיפוס שמממש את ה-trait הזה חייב לספק את שתי הפעולות האלה עם החתימות המדויקות האלה.

כך struct עשוי לממש זאת:

struct BasicCalc;

impl Calculator for BasicCalc {
    fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
    
    fn multiply(&self, a: i32, b: i32) -> i32 {
        a * b
    }
}

עכשיו אפשר להשתמש בשיטות האלה עם ארגומנטים:

let calc = BasicCalc;
println!("{}", calc.add(5, 3));       // 8
println!("{}", calc.multiply(4, 7));  // 28

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

אתגר

קל

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

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

processor.rs: הגדירו טרייט ציבורי בשם TextProcessor עם שתי מתודות שמקבלות פרמטרים:
- repeat(&self, text: &str, times: u32) -> String: חוזרת על הטקסט הנתון מספר פעמים מוגדר
- truncate(&self, text: &str, max_len: usize) -> String: מקצרת את הטקסט לאורך המרבי שהוגדר
processors.rs: צרו שני מבנים ציבוריים שמממשים את הטרייט שלכם:
- SimpleProcessor: מבנה יחידה שחוזר על הטקסט עם רווחים בין כל חזרה (למשל, חזרה על "Hi" שלוש פעמים יוצרת "Hi Hi Hi") ומקצר פשוט על ידי חיתוך באורך המרבי
- FancyProcessor: מבנה יחידה שחוזר על הטקסט עם " * " בין החזרות (למשל, חזרה על "Hi" שלוש פעמים יוצרת "Hi * Hi * Hi") ומקצר על ידי הוספת "..." אם הטקסט קוצר (רק אם הטקסט המקורי היה ארוך מ-max_len)
main.rs: חברו את המודולים שלכם והדגימו כיצד אותן מתודות של הטרייט מפיקות תוצאות שונות בהתאם למעבד שבו משתמשים.

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

הדפיסו ארבע שורות שמציגות את ההתנהגות של כל מעבד:

Simple repeat: {result}
Simple truncate: {result}
Fancy repeat: {result}
Fancy truncate: {result}

לדוגמה, עם הקלטים Hello, 3 ו-4:

Simple repeat: Hello Hello Hello
Simple truncate: Hell
Fancy repeat: Hello * Hello * Hello
Fancy truncate: Hell...

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

תקבלו שלושה קלטים: הטקסט לעיבוד, מספר החזרות (יש לנתח כ-u32) והאורך המרבי לקיצור (יש לנתח כ-usize).

נסו בעצמכם

mod processor;
mod processors;

use processor::TextProcessor;
use processors::{SimpleProcessor, FancyProcessor};

fn main() {
    // קרא את הקלטים
    let mut text = String::new();
    std::io::stdin().read_line(&mut text).expect("Failed to read line");
    let text = text.trim();
    
    let mut times_input = String::new();
    std::io::stdin().read_line(&mut times_input).expect("Failed to read line");
    let times: u32 = times_input.trim().parse().expect("Failed to parse times");
    
    let mut max_len_input = String::new();
    std::io::stdin().read_line(&mut max_len_input).expect("Failed to read line");
    let max_len: usize = max_len_input.trim().parse().expect("Failed to parse max_len");
    
    // צור מעבדים
    let simple = SimpleProcessor;
    let fancy = FancyProcessor;
    
    // TODO: השתמש במעבדים כדי לשנות את הטקסט ולהדפיס את התוצאות
    // הדפס ארבע שורות:
    // Simple repeat: {result}
    // Simple truncate: {result}
    // Fancy repeat: {result}
    // Fancy truncate: {result}
}