Shapes ב-Zero: הגדרת רשומות בסגנון struct

הצהרה על Shape

shape הוא טיפוס רשומה עם שדות בעלי שם וטיפוס:

shape Point {
    x: i32,
    y: i32,
}

החלקים:

• shape פותח את ההצהרה.
• Point הוא שם הטיפוס.
• הסוגריים המסולסלים עוטפים רשימה של שדות, כל אחד בצורה name: Type.

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

בניית ערך Shape

יוצרים מופע עם ביטוי ליטרל של struct:

let point = Point { x: 40, y: 2 }

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

{
    "code": "FLD002",
    "message": "missing field: y",
    "line": 4
}

(קוד השגיאה המדויק עשוי להשתנות; העיקרון של "אין ברירות מחדל מרומזות" הוא הקבוע.)

אפשר לציין את הטיפוס במפורש אם רוצים שהוא יהיה גלוי:

let point: Point = Point { x: 40, y: 2 }

קריאת שדות

גישה לשדות משתמשת בתחביר נקודה:

let point = Point { x: 40, y: 2 }
let xVal  = point.x
let yVal  = point.y

point.x קורא את השדה x. אין מתודה get_x(): שדות הם נתונים פשוטים.

דוגמה מלאה

זו דוגמת point.0 הקנונית מהמאגר של השפה. לחצו על Run כדי לנסות:

shape Point {
    x: i32,
    y: i32,
}

fun sum(point: Point) -> i32 {
    return point.x + point.y
}

pub fun main(world: World) -> Void raises {
    let point = Point { x: 40, y: 2 }
    let total = sum(point)
    if total == 42 {
        check world.out.write("point works\n")
    } else {
        check world.out.write("point broke\n")
    }
}

נעבור עליה מההתחלה:

1. מצהירים על shape בשם Point עם שני שדות i32.
2. מגדירים פונקציה sum שמקבלת Point ומחזירה את סכום השדות שלו.
3. ב-main, בונים Point, קוראים ל-sum ומשווים את התוצאה.

שלושה צעדים, שלושה רעיונות שקשורים ל-shapes (הצהרה, בנייה, גישה), ואפקט אחד: ה-check world.out.write(...) בסוף. שימו לב ש-sum לא נוגעת ב-World. זו פונקציה טהורה על נתונים, והחתימה הופכת את זה לברור.

Shapes עם שדות מקוננים

shape יכול להחזיק ערכים מכל טיפוס, כולל shapes אחרים:

shape Range {
    start: i32,
    end: i32,
}

shape Segment {
    label: String,
    range: Range,
}

let seg = Segment {
    label: "warmup",
    range: Range { start: 0, end: 10 },
}

גישה לשדות משתרשרת כמו שהייתם מצפים:

let len = seg.range.end - seg.range.start

Shapes גנריים

כשהשדות של shape צריכים להיות פולימורפיים בטיפוס, מצהירים על פרמטרי טיפוס בסוגריים משולשים:

shape Pair<T, U> {
    left: T,
    right: U,
}

המופעים קובעים את הפרמטרים לטיפוסים קונקרטיים:

let intBytePair: Pair<i32, u8> = Pair { left: 40, right: 2_u8 }
let words: Pair<String, String> = Pair { left: "hello", right: "world" }

כינוי טיפוס יכול לקצר פרמטריזציה נפוצה:

type BytePair = Pair<u8, u8>

let bytes: BytePair = Pair { left: 1_u8, right: 2_u8 }

Generics מכסה פרמטרי טיפוס לעומק, כולל בפונקציות ולא רק ב-shapes.

מה Shapes הם לא

כמה דברים שאולי הייתם מצפים להם מ-"struct" בשפה אחרת ו-shapes בכוונה לא כוללים:

• אין מתודות. הצהרת shape היא נתונים בלבד. ההתנהגות נמצאת בפונקציות חופשיות שמקבלות את ה-shape כפרמטר. זה משקף את אותה הפרדה בין נתונים לאפקטים שרואים בפונקציות.
• אין ירושה. Shapes לא מרחיבים shapes אחרים. אם רוצים מבנה משותף, הוציאו אותו לשדה משותף או בנו טיפוס סכום עם choice.
• אין בנאים או destructors מרומזים. הבנייה היא ביטוי הליטרל של ה-struct. הניקוי מפורש: כשהספרייה הסטנדרטית חושפת משאבים שצריך לשחרר, זה נעשה דרך ממשקים בסגנון יכולות ולא דרך RAII נסתר.
• אין שדות פרטיים. כל השדות של shape נגישים לקוד שיכול לראות את הטיפוס של ה-shape. הנראות היא ברמת הטיפוס, לא ברמת השדה.

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

מתי להשתמש ב-Shape ומתי ב-Choice

מדריך מהיר:

• השתמשו ב-shape כשלערך יש את כל השדות האלה יחד. ל-Point יש תמיד גם x וגם y.
• השתמשו ב-choice כשערך הוא אחת מתוך כמה חלופות. Result הוא או ok או err.
• השתמשו ב-enum כשהחלופות לא נושאות נתונים נוספים: הן רק תוויות. ימות השבוע, מצבים פשוטים.

שלוש אבני הבניין האלה, shape (וגם), choice (או), enum (או בלי מטען), מכסות כמעט כל צורך במידול נתונים.

הבא בתור: Generics

ראיתם את Pair<T, U> מופיע בדרך אגב. המסמך הבא, generics, מסביר איך פרמטרי טיפוס עובדים גם ב-shapes וגם בפונקציות, כולל הדפוסים שמופיעים בכל הספרייה הסטנדרטית של Zero.