Rhombus 1.1: הרחבת תחביר, מאקרואים ואנוטציות נבדקות

ברוכים הבאים למדריך SysSeder ל־Rhombus 1.1.

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

כאן נכנסת Rhombus.

Rhombus היא שפה הבנויה על Racket, עם תחביר shrubbery מקובץ ומאקרואים ניתנים להרחבה. גרסה 1.1 הוכרזה ב־17 באוגוסט 2026. זהו שחרור אמיתי, אך עצם קיומו אינו מאשר מוכנות לייצור לכל פרויקט ואינו מוכיח שלמות תכונות.

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

הרעיון המרכזי: כוח של Lisp, תחביר מודרני

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

Rhombus משלבת אופרטורים תוכיים, גישת נקודה וקיבוץ בהזחה. Shrubbery מספקת שכבת תחביר מובְנית לפני הפירוש המיוחד לשפה; זו אינה פשוט עץ התחביר הסופי או החלפת טקסט גולמית. הרחבת מאקרו מרחיבה ניתוח ומשמעות בזמן ההרחבה, לא משכתבת ללא גבול מהדר פועל.

יכולות השפה והשינויים הממשיים ב־1.1

התאמת תבניות היא יכולת של השפה, ולא חידוש שנקבע בהכרזת 1.1. ההכרזה מוסיפה את צורת הקשירה as וקיצורי הגדרת אנוטציות כגון annot ו־annot.def.
מחלקות וממשקים תומכים בהפשטה מונחית עצמים. גרסה 1.1 משנה כיצד שמות נורשים נקשרים דרך הפניות למחלקת אב או לממשק; זו אינה הבטחת ביצועים כללית.
אנוטציות ומידע סטטי: Rhombus היא דינמית. האופרטור :: בודק אנוטציה, ואילו :~ מספק מידע סטטי ללא בדיקה בזמן ריצה. תיאור שתי הצורות כבודק טיפוסים הדרגתי רגיל מסתיר את ההבחנה החשובה הזאת.
תאימות: Racket ו־Rhombus חולקות מערכת מודולים, אך לא כל קשירה מיובאת ניתנת לשימוש ישיר. בפרט, צורת תחביר של Racket זקוקה בדרך כלל לגשר מאקרו של Rhombus; ״גישה חלקה לכול״ היא טענה רחבה מדי.

מתחילים: תוכנית Rhombus ראשונה

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

#lang racket
(define (fib n)
  (cond [(< n 2) n]
        [else (+ (fib (- n 1)) (fib (- n 2)))]))

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

#lang rhombus

fun fib(n):
  cond
  | n < 2: n
  | ~else: fib(n - 1) + fib(n - 2)

// Illustrative call; not executed here.
println(fib(10)) // Mathematically expected: 55, not an observed test result.

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

מאחורי הקלעים: סימון Shrubbery ומאקרואים

אובייקטי התחביר של Rhombus מייצגים קבוצות shrubbery ושומרים מידע לקסיקלי. גם אובייקטי התחביר של Racket כוללים יותר מרשימה פשוטה; צמצום מערכת מאקרו להחלפת טקסט או שינוי עץ בלבד מחמיץ מידע על קשירות.

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

בניית מאקרו מותאם לזרימת בקרה

Rhombus כבר מספקת unless. כדי ללמוד הרחבה בלי להחליף קשירה קיימת, נגדיר unless_demo עם תנאי בסוגריים וגוף מוזח. הוא מבצע את הגוף רק כשהתנאי הוא #false.

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

#lang rhombus

// Educational template macro; not executed here.
macro 'unless_demo ($condition): $body':
  'if $condition
   | #void
   | block:
       $body'

fun check_threshold(val):
  unless_demo (val > 100):
    println("אזהרה: הערך נמצא בסף או מתחתיו.")

check_threshold(85)
check_threshold(120)

נפרק את המתרחש:

macro מגדיר מאקרו ביטוי פשוט מתבנית התאמה ומתבנית תחביר ישירה. expr.macro היא הצורה הכללית יותר ודורשת את יכולות meta; היא אינה נחוצה בדוגמה המתוקנת.
אנו משתמשים באופרטור ציטוט התחביר, '...', כדי להתאים תבניות ולבנות תבניות תחביר.
$condition ו־$body קושרים תחביר מותאם. הסוגריים תוחמים את קבוצת התנאי כולה, ותבנית הבלוק לוכדת את הגוף. על מחבר המאקרו לבחור תבנית המתאימה לדקדוק הרצוי, ולא להניח שאסימון יחיד תמיד מייצג ביטוי מלא.
התבנית מתרחבת ל־if: תנאי אמת מחזיר #void, ותנאי שקר מעריך את בלוק הגוף. התנאי מופיע פעם אחת בהרחבה, ולכן תכנון זה אינו מכפיל את הערכתו.

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

הכוח של מחלקות וממשקים ב־Rhombus 1.1

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

#lang rhombus

interface Shape:
  method area() :: Real
  method describe() :: String

class Circle(radius :: Real):
  implements Shape
  override area():
    3.14159 * radius * radius
  override describe():
    "עיגול ברדיוס " +& radius

class Square(side :: Real):
  implements Shape
  override area():
    side * side
  override describe():
    "ריבוע עם צלע " +& side

fun print_shape_info(s :: Shape):
  println(s.describe())
  println("שטח: " +& s.area())

let my_circle = Circle(5)
let my_square = Square(4)
print_shape_info(my_circle)
print_shape_info(my_square)

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

למה מפתחי רשת ו־DevOps צריכים להתעניין?

למה לשקול זאת אם עבודתכם מתמקדת ב־API או בתשתיות? השאלה היא אם סימון ייעודי לתחום יבהיר בעיה ממשית, לא אם שפה חדשה טובה יותר מעצם טבעה.

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

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

סיכום: עתיד השפות הניתנות להרחבה

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

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

עכשיו תורכם!

מה דעתכם על Rhombus? האם אתם מסורתיים של Lisp שאוהבים סוגריים, או שהתחביר המודרני דמוי Python מעורר בכם רצון להביט שוב בסביבת Racket? ספרו בתגובות למטה!

עד הפעם הבאה, פיתוח מהנה!