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

1. קצת על ראסט

ראסט פותחה במוזילה על ידי Graydon Hoare והופיעה לראשונה ביולי 2010. גריידון עבד במוזילה בזמן הפיתוח והעיצוב של השפה, וגירסה יציבה ראשונה יצאה ב 2014. היום משתמשים בראסט בחברות מובילות בתעשיה כולל אמזון, דיסקורד, דרופבוקס, פייסבוק, גוגל ומייקרוסופט. החל מ 2021 הפיתוח של ראסט מנוהל וממומן דרך ה Rust Foundation שהוקם כשיתוף פעולה בין AWS, Huawei, Google, Microsoft ו Mozilla.

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

ראסט כוללת מערכת טיפוסים נוקשה כך שלכל דבר יש טיפוס, ומשלבת את זה עם Type Inference כך שאנחנו כמעט לא צריכים לכתוב הגדרות לטיפוסים. היא מתקמפלת לכל הפלטפורמות וכוללת מודל ניהול זיכרון חדשני (שעדיין לא הבנתי אותו עד הסוף) שמאפשר לקומפיילר לדאוג לניקוי הזיכרון בלי להזדקק ל Garbage Collector או Reference Count.

2. התוכנית - תרגיל ראשון של AoC 2021

בשביל להבין את ראסט קצת מעבר ל Tutorail הראשון הלכתי לממש את התרגיל הראשון מ Advent Of Code האחרון. עם הזמן אולי אממש גם את הבאים. בתרגיל אנחנו צריכים לקרוא קובץ טקסט שמכיל מספרים ולהגיד כמה מהשורות בקובץ מכילות מספר שגדול יותר מהמספר שהיה קודם. לדוגמה אם הקובץ מכיל את:

199
200
208
210
200
207
240
269
260
263

אז אפשר לראות ש 7 שורות הן גדולות יותר מהשורה שלפניהן.

בחלק השני של התרגיל יש לאסוף את השורות לקבוצות של 3 ולסכום את הערכים בכל קבוצה. האיור הבא ממחיש את זה כשכל אות מייצגת קבוצה:

199  A      
200  A B    
208  A B C  
210    B C D
200  E   C D
207  E F   D
240  E F G  
269    F G H
260      G H
263        H

סכומי הקבוצות הם:

A: 607 (N/A - no previous sum)
B: 618 (increased)
C: 618 (no change)
D: 617 (decreased)
E: 647 (increased)
F: 716 (increased)
G: 769 (increased)
H: 792 (increased)

ובחלוקה כזאת אני רואה ש 5 קבוצות מייצרות סכום גדול יותר ממה שהיה בשורה הקודמת.

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

3. פיתרון ב Rust

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

use std::env;
use std::fs;

fn part1<'a>(it: impl Iterator<Item=&'a u32>) -> u32 {
    let mut increases = 0;
    let mut previous_line = f64::INFINITY;

    for value in it {
        if f64::from(*value) > previous_line {
            increases += 1;
        }
        previous_line = f64::from(*value);
    }

    return increases;
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let file_path = &args[1];

    let contents = match fs::read_to_string(file_path) {
        Ok(c) => c,
        Err(error) => panic!("Problem opening the file: {} - {:?}", file_path, error),
    };

    let lines = contents.split("\n");

    let values: Vec<u32> = lines.filter_map(|v| v.trim().parse::<u32>().ok()).collect();

    let it1 = values.iter();
    let it2 = values.iter().skip(1);
    let it3 = values.iter().skip(2);
    let values_for_part2: Vec<u32> = it1.zip(it2).zip(it3).map(|((a, b), c)| a + b + c).collect();

    let sol1 = part1(values.iter());
    let sol2 = part1(values_for_part2.iter());

    dbg!(sol1);
    dbg!(sol2);
}

4. מבנה כללי של הקובץ

הקובץ כולל שלושה חלקים:

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

2. פקודות fn מגדירות פונקציות, ובקובץ קיימות שתי פונקציות: הפונקציה part1 והפונקציה main.

השם main הוא השם של הפונקציה הראשית בתוכנית שמופעלת כשהתוכנית מתחילה.

5. הפונקציה main

הפונקציה main בקוד מחולקת גם היא למספר חלקים:

1. פיענוח פרמטרים שעברו משורת הפקודה.

2. קריאת קובץ הקלט.

3. המרת הקלט למספרים.

4. הפעלת פונקציית העזר כדי לספור כמה שורות גדולות יותר מאלה שלפניהן.

5. המרת הקלט לקבוצות וסכימת המספרים בכל קבוצה.

6. קריאה נוספת לפונקציית העזר כדי לחשב את החלק השני.

בחלק הראשון אני לוקח את הפרמטר הראשון משורת הפקודה לתוך משתנה בשם file_path:

let args: Vec<String> = env::args().collect();
let file_path = &args[1];

הפקודה collect לוקחת משהו שאפשר לרוץ עליו (איטרטור) והופכת אותו למבנה נתונים. בשורה הראשונה לוקחים את כל הארגומנטים שהתוכנית קיבלה ושומרים אותם במבנה נתונים מסוג וקטור.

שורה שניה לוקחת את התא הראשון בוקטור ושומרת אותו במשתנה בשם file_path.

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

נמשיך לקריאת הקובץ ופה אנחנו רואים איך ראסט עוזר לנו לכתוב תוכניות בטוחות יותר By Design:

let contents = match fs::read_to_string(file_path) {
    Ok(c) => c,
    Err(error) => panic!("Problem opening the file: {} - {:?}", file_path, error),
};

הפקודה fs::read_to_string לוקחת שם קובץ וקוראת את הקובץ למחרוזת. אבל קריאה של קובץ זה משהו שיכול להיכשל - ולכן הפקודה מחזירה משהו שנקרא Result. ל Result יש שתי אפשרויות, או שהוא תקין ואז יש לנו את המחרוזת, או שהוא מייצג שגיאה. הפקודה match מאפשרת לנו ולקומפיילר לטפל בכמה אפשרויות ומוודאת שטיפלנו בכולן, והפקודה panic זורקת שגיאה ומרסקת את התוכנית.

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

let contents = fs::read_to_string(file_path);
let lines = contents.split("\n");

התוכנית לא מתקמפלת כי ל Result אין פונקציה בשם split.

קיצור דרך שכן אפשר לכתוב ויעבוד הוא:

let contents = fs::read_to_string(file_path).expect("Error");
let lines = contents.split("\n");

וזה ייתן בדיוק את אותה התנהגות.

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

let values: Vec<u32> = lines
    .filter_map(|v| v.trim().parse::<u32>().ok())
    .collect();

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

אפשר לראות שאני מציין טיפוסים רק איפה שאני צריך אותם - אני צריך להגיד ל collect איזה סוג מבנה נתונים לייצר, ואני צריך להגיד ל parse לאיזה טיפוס לנסות לפענח. הטיפוס u32 הוא Unsigned Integer באורך 32 ביטים.

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

let sol1 = part1(values.iter());
dbg!(sol1);

הפקודה dbg! פשוט מדפיסה את הערך שקיבלה לצרכי debug.

בשביל החלק השני של החלוקה לקבוצות הקוד קצת יותר יצירתי אבל לא יותר מדי. המתודה zip של איטרטור לוקחת איטרטור אחר ומחזירה זוג של ערכים מכל אחד מהאיטרטורים. הפקודה skip מדלגת על איבר באיטרטור ולכן אני יוצר 3 איטרטורים כל אחד מתחיל מאיבר אחד קדימה:

let it1 = values.iter();
let it2 = values.iter().skip(1);
let it3 = values.iter().skip(2);

מחבר את שלושתם עם zip על zip ומשתמש ב map כדי לסכום את האיברים בכל שלשה:

let values_for_part2: Vec<u32> = it1.zip(it2).zip(it3).map(|((a, b), c)| a + b + c).collect();

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

לסיום נעביר איטרטור על הוקטור לפונקציית העזר ולהדפיס את התוצאה של החלק השני:

let sol2 = part1(values_for_part2.iter());
dbg!(sol2);

6. הפונקציה part1

נמשיך לקריאת פונקציית העזר:

fn part1<'a>(it: impl Iterator<Item=&'a u32>) -> u32 {
    let mut increases = 0;
    let mut previous_line = f64::INFINITY;

    for value in it {
        if f64::from(*value) > previous_line {
            increases += 1;
        }
        previous_line = f64::from(*value);
    }

    return increases;
}

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

מבחינת הקוד המילה mut לפני שם משתנה אומרת שאני הולך לשנות אותו במהלך הריצה (ברירת המחדל היא שמשתנים מקבלים ערך רק פעם אחת - כלומר const). ובלולאה ה for אני בודק אם הערך הנוכחי גדול מהערך הקודם ואם כן מעלה את המונה. ההמרה ל Float נדרשת כי הערך הראשוני של previous_line היה אינסוף (כדי שהאיבר הראשון לא יהיה גדול ממנו), ואינסוף בראסט הוא מטיפוס float.

7. לאן להמשיך מכאן

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

https://doc.rust-lang.org/stable/book/

או על המדריך Rust By Example בקישור הזה:

https://doc.rust-lang.org/stable/rust-by-example/