קישורי let ב-Zero: מתן שמות לערכים

דרך אחת לתת שם לערך

ב-Zero נותנים לערך שם עם let:

let answer = 42

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

let יוצר קישור מקומי בתחום הנוכחי. אחרי השורה הזו, answer מתייחס ל-42 עד סוף הבלוק שעוטף אותו.

הסקת טיפוסים

הקומפיילר מסיק את הטיפוס מהביטוי שאחרי סימן השוויון. לליטרל 42 יש כברירת מחדל טיפוס i32, ולכן answer הוא i32. הליטרל "hello" הוא מחרוזת, ולכן:

let greeting = "hello"

קושר את greeting לערך מחרוזת. אם קוראים לפונקציה שמחזירה Pair<i32, u8>, לקישור יש טיפוס Pair<i32, u8>:

let pair = makePair(40, 2_u8)

לא צריך לכתוב את הטיפוס על כל קישור, וכך הקוד נשאר קריא.

הערות טיפוס מפורשות

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

let count: u8 = 10
let pair:  Pair<i32, u8> = makePair(40, 2_u8)

הערות טיפוס הן גם רמז לקומפיילר כשליטרל יכול להיות אחד מכמה טיפוסים. הליטרל 10 יכול להיות i32, i64, u8 וכן הלאה; ההערה קובעת אותו.

תראו גם סיומות טיפוס על ליטרלים כחלופה להערה על הקישור:

let small = 10_u8   // u8 מסיומת הליטרל
let big   = 10_i64  // i64 מסיומת הליטרל

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

קישורים בפעולה

דוגמה מלאה שמשתמשת גם בצורה המוסקת וגם בצורה המפורשת. לחצו על 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 = Point { x: 40, y: 2 }
    let total = sum(point)
    if total == 42 {
        check world.out.write("point works\n")
    }
}

ל-point יש הערת טיפוס מפורשת כי הביטוי שאחרי סימן השוויון הוא ליטרל של struct. הטיפוס של total מוסק: sum מוצהרת כמחזירה i32, ולכן גם הקישור הוא i32.

תחום והסתרה

קישור let תקף מהשורה שמצהירה עליו ועד סוף הבלוק שעוטף אותו. בלוקים מקוננים יוצרים תחומים חדשים:

pub fun main(world: World) -> Void raises {
    let value = 1
    if true {
        let value = 2   // מסתיר את 'value' החיצוני בתוך הבלוק הזה
        // כאן, value == 2
    }
    // שוב מחוץ ל-if, value == 1
}

ה-value הפנימי לא משנה את החיצוני: זה קישור נפרד שיוצא מהתחום בסוגר המסולסל שסוגר את בלוק ה-if. זה אותו מודל כמו ב-Rust ובשפות ממשפחת ML. זה נפוץ במיוחד כשרוצים להעביר ערך דרך סדרה של שלבים בלי להמציא שם חדש לכל תוצאת ביניים.

מה let לא עושה

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

• הצהרות של טיפוס בלבד. אין צורה let x: i32; שיוצרת קישור לא מאותחל. לקישור חייב להיות ערך בנקודה שבה הוא מוצהר.
• פירוק תבניות (עדיין). שפות מסוימות מאפשרות לכתוב let (a, b) = pair. Zero קטנה מעצם העיצוב שלה וכרגע מתמקדת בקישורי שמות פשוטים: בדקו בתיעוד העדכני אם פירוק כבר נוסף.
• כמה מילות מפתח לאורכי חיים שונים. אין static, const, let mut נפרדים, ואין וריאנטים לתחום בלוק מול תחום פונקציה. מילת מפתח אחת.

אם הרקע שלכם הוא JavaScript, האנלוגיה הקרובה ביותר היא const: שם שקשור לערך עד סוף הבלוק, עם הסתרה בתחומים פנימיים. אם הרקע שלכם הוא Rust, let כאן ממלא את אותו תפקיד כמו let של Rust, בלי מילת המפתח המפורשת mut.

דפוס: בניית ערך צעד אחר צעד

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

pub fun main(world: World) -> Void raises {
    let raw     = 21
    let doubled = raw * 2
    let label   = "result\n"
    if doubled == 42 {
        check world.out.write(label)
    }
}

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

הבא בתור: טיפוסים פרימיטיביים

ל-let אין הרבה משמעות בלי משהו לקשור. המסמך הבא עובר על הטיפוסים הפרימיטיביים של Zero: רוחבי המספרים השלמים, מספרים עשרוניים, מחרוזות, והטיפוסים Void ו-Bool שתראו הכי הרבה.