הצגת המקור של הדף "מודולה-2"

{{שפת תכנות
| שם = מוֹדוּלה־2
| שם בשפת המקור = Modula-2
| תמונה = [[קובץ:Niklaus Wirth Programming in Modula-2 Springer 1988.jpeg|150px]]
| כיתוב = המדריך של מודולה־2 מאת ניקלאוס וירת, מהדורה רביעית ב[[הוצאת שפרינגר]], 1988.
| מתכנן = [[ניקלאוס וירת]]
| מפתח = [[ניקלאוס וירת]]
| תאריך גרסה אחרונה = 1985
| טיפוסיות = חזקה, סטטית
| מימושים = ETH, GNU, ADW
| ניבים = PIM2, PIM3, PIM4, ISO
| הושפעה על ידי = [[Mesa (שפת תכנות)|מֶסה]],<ref name=":1guide"  group="א" /> [[פסקל (שפת תכנות)|פסקל]],<ref name=":1guide"  group="א" /> [[מודולה]]<ref name=":1guide"  group="א" />
| השפיעה על = [[מודולה-3|מודולה־3]], [[עדה (שפת תכנות)|עדה]], [[לואה (שפת תכנות)|לואה]]
}}'''מוֹדוּלה־2''' (ב[[אנגלית]]: '''Modula-2''') היא [[שפת תכנות]] מערכות [[תכנות מובנה|מובנת]] ו[[תכנות פרוצדורלי|פרוצדורלית]] עם [[טיפוסיות חזקה]] וסטטית שפותחה על ידי [[ניקלאוס וירת]] בין השנים 1977–1988 ב[[המכון הטכנולוגי של ציריך|מכון הטכנולוגי של ציריך]].<ref name=":1">{{קישור כללי|כתובת=https://people.inf.ethz.ch/wirth/projects.html|כותרת=Summary of projects by N. Wirth, 1962 - 1999|אתר=people.inf.ethz.ch|תאריך_וידוא=2020-11-11}}</ref> מודולה־2 הורחבה במקור מ[[פסקל (שפת תכנות)|פסקל]],<ref>{{צ-מאמר|שם=The programming language Pascal|קישור=https://doi.org/10.1007/BF00264291|כתב עת=Acta Informatica|שנת הוצאה=1971|עמ=35–63|כרך=1|doi=10.1007/BF00264291|מחבר=Niklaus Wirth}}</ref> והיא ירשה את הפיתוח של [[מודולה]].<ref>{{צ-מאמר|שם=Modula: A language for modular multiprogramming|קישור=https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.4380070102|כתב עת=Software: Practice and Experience|שנת הוצאה=1977|עמ=1–35|כרך=7|doi=10.1002/spe.4380070102|מחבר=Niklaus Wirth}}</ref> מודולה־2 באה לתת מענה מקיף לכל החסרונות של פסקל.<ref name=":1" /><ref>{{קישור כללי|כתובת=http://wiki.c2.com/?ModulaTwo|כותרת=Modula Two|אתר=wiki.c2.com|תאריך_וידוא=2021-04-04}}</ref><ref name=":1guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Preface, pp. 3–5</ref><ref name=":0report" group="ב">[[מודולה-2#Report|Report]], Introduction, pp. 133–134</ref>

== היסטוריה ==
בשנת 1976 [[ניקלאוס וירת|וירת]] ביקר במעבדת [[פארק (חברה)|פארק]], היכן שתפס את ההשראה לפיתוח של מודולה־2 משפת התכנות [[Mesa (שפת תכנות)|מֶסַה]].<ref name=":1guide" group="א" /><ref name=":1" />
[[קובץ:Diser Lilith-IMG 1729.jpg|ממוזער|180x180 פיקסלים|בשנת 1980 [[DISER Lilith]] היה המחשב הראשון שהושק עם מערכת הפעלה שפותחה במודולה־2.<ref name=":1" />]]
בשנת 1977 וירת התחיל את הפיתוח של מודולה־2 כהמשך לפיתוח של [[מודולה (שפת תכנות)|מודולה]], וכתחליף ל[[פסקל (שפת תכנות)|פסקל]].<ref name=":1guide" group="א" /> מודולה הראשונה הייתה שפת תכנות נסיונית, והיא מעולם לא פותחה מעבר לשלבי הניסוי שלה אחרי שנת 1975. וירת תכנן את מודולה־2 שתהיה [[שפת תכנות Low-level|שפת תכנות מערכות]] ו[[שפת תכנות כללית]] במחשבי [[DISER Lilith]].<ref name=":1" /><ref name=":1guide" group="א" /> תחביר השפה היה דומה יותר לזה של מודולה מאשר לפסקל, לכן וירת החליט לקרוא לה מודולה־2.<ref name=":1guide" group="א" />

בשנת 1978 פורסמה המהדורה הראשונה של הדו"ח של אפיון השפה.<ref>{{צ-מאמר|שם=MODULA-2|קישור=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/69215/eth3131-01.pdf?sequence=1&isAllowed=y|שנת הוצאה=1978|doi=10.3929/ethz-a-000153014|מחבר=Niklaus Wirth|מו"ל=ETH Zürich|כרך=27|כתב עת=ETH, Institut für Informatik}}</ref>

בשנת 1979 נוצר ה[[יישום]] השימושי הראשון של השפה עבור מחשבי ה־[[PDP|PDP-11]] בשימוש פנימי של ה[[המכון הטכנולוגי של ציריך|מכון הטכנולוגי של ציריך]].<ref name=":1guide" group="א" />

בשנת 1980 פורסמה המהדורה השנייה של הדו"ח של האפיון השפה.<ref>{{צ-מאמר|שם=MODULA-2|קישור=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/68683/eth-3135-01.pdf?sequence=1&isAllowed=y|שנת הוצאה=1980|doi=10.3929/ethz-a-000189918|מחבר=Niklaus Wirth|מו"ל=ETH Zürich|כרך=36|כתב עת=ETH, Institut für Informatik}}</ref><ref name=":1guide" group="א" />

בשנת 1981 [[מהדר]] השפה שוחרר בפעם הראשונה לציבור הרחב.<ref name=":1guide" group="א" /> מיד לאחר מכן השפה צברה פופולריות ונוצר עניין ציבורי בפרסום מדריך רשמי עבור השפה.<ref name=":1guide" group="א" />

בשנת 1982 פורסמה הגרסה הראשונה של מדריך השפה מאת ניקלאוס וירת על ידי [[הוצאת שפרינגר]].<ref>{{צ-ספר|שם=Programming in Modula-2|קישור=https://www.springer.com/gp/book/9783642967177|מו"ל=Springer-Verlag|שנת הוצאה=1982|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-96717-7|מחבר=Niklaus Wirth|שפה=en|מהדורה=1st Edition}}</ref>

בשנת 1983 פורסמה הגרסה השנייה של השפה (PIM2).<ref>{{צ-ספר|שם=Programming in Modula-2|קישור=https://link.springer.com/book/10.1007/978-3-642-96757-3|מו"ל=Springer-Verlag|שנת הוצאה=1983|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-96757-3|מחבר=Niklaus Wirth|שפה=en|מהדורה=2nd Edition}}</ref>

בין השנים 1983–1985 וירת החליט לפתח מהדר משלו עבור השפה. המהדר של וירת היה מהיר ויעיל בהרבה מהמהדרים שהוצעו עד כה לשפה.<ref name=":1" /><ref name=":0wirth">{{צ-מאמר|שם=A fast and compact compiler for Modula-2|קישור=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/69199/eth-3296-01.pdf?sequence=1&isAllowed=y|שנת הוצאה=1985|doi=10.3929/ethz-a-006650101|מחבר=Niklaus Wirth, Jürg Gutknecht|כתב עת=ETH, Institut für Informatik|מו"ל=ETH Zürich|כרך=64}}</ref>

בשנת 1985 פורסמה הגרסה השלישית של השפה (PIM3).<ref>{{צ-ספר|שם=Programming in Modula-2|קישור=http://link.springer.com/10.1007/978-3-642-96878-5|מו"ל=Springer-Verlag|שנת הוצאה=1985|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-96880-8|מחבר=Niklaus Wirth|שפה=en|מהדורה=3rd Edition}}</ref>

בשנת 1988 פורסמה הגרסה הרביעית של השפה (PIM4).<ref name=":12wirth">{{צ-ספר|שם=Programming in Modula-2|קישור=https://link.springer.com/book/10.1007/978-3-642-83565-0|מו"ל=Springer-Verlag|שנת הוצאה=1988|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-83567-4|מהדורה=4th Edition|מחבר=Niklaus Wirth|שפה=en}}</ref>

בשנת 1989 וירת פרסם מאמר בו התייחס ל[[תכנות מונחה-עצמים|תכנות מונחה עצמים]] במודולה־2, למרות שבמקור לא עוצבה לכך. במאמר וירת הציע פתרון לחיקוי הורשה במודולה־2 באמצעות היכולת של השפה להתעלם מאכיפת טיפוסיות ב[[שפת תכנות Low-level|תכנות מערכות]].<ref>{{צ-מאמר|שם=Modula-2 and object-oriented programming|קישור=https://www.research-collection.ethz.ch/bitstream/handle/20.500.11850/68705/eth-3247-01.pdf?sequence=1&isAllowed=y|שנת הוצאה=1989|doi=10.3929/ethz-a-000523424|מחבר=Niklaus Wirth|כרך=117|מו"ל=ETH Zürich|כתב עת=ETH, Institut für Informatik}}</ref>

בשנת 1996 [[ארגון התקינה הבינלאומי|ארגון התקינה הבין־לאומי]] (ISO) פרסם [[תקן]] מקיף לשפת התכנות מודולה־2. מכיוון שהיו בו שינויים מזעריים אך מחייבים בשפה, הוא נחשב לניב נוסף של השפה.<ref>{{קישור כללי|כתובת=https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/01/85/18583.html|הכותב=|כותרת=ISO/IEC 10514-1:1996|אתר=ISO|שפה=en|תאריך_וידוא=2021-09-20}}</ref>

בשנת 2010 שוחררה הגרסה הראשונה של ה[[מימוש]] ה[[תוכנה חופשית|חופשי]] GNU Modula-2 עבור ה[[מהדר]] [[GCC]] לציבור הרחב מטעם [[מיזם גנו]].<ref name=":5" />

בשנת 2011 שוחררה הגרסה הראשונה של ה[[מהדר]] ה[[תוכנה חינמית|חינמי]] ADW Modula-2 לציבור הרחב אחרי שירש את הפיתוח של המהדר Stony Brook Modula-2.<ref name=":3" />

=== תיעוד ===
מדריך השפה יצא לאור בארבע מהדורות בין השנים 1982–1988. המהדורות שיקפו על שינויים בשפה. סקירת השפה פורסמה באופן חופשי לקהל הרחב בגרסת [[PDF]] מתוך מדריך השפה. הסקירה כוללת בה אפיון מלא של השפה.<ref group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Report on the Programming Language Modula-2, pp. 133–156</ref> גרסת ה־PDF שפרסמה [[הוצאת שפרינגר]] כוללת בה גם את ארבעת הנספחים האחרונים בספר: הגדרת תחביר השפה בסימון [[EBNF]] {{אנ|Extended Backus–Naur form}},<ref name=":7guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], The Syntax of Modula-2, pp. 157–160</ref> תיאור ספריית הליבה של מודולה־2,<ref group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Appendix 2: Standard Utility Modules, pp. 161–169</ref> טבלת תוי [[ASCII]],<ref group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Appendix 3: The ASCII Character Set, p. 170</ref> ו[[תרשים זרימה|תרשימי זרימה]] לתחביר השפה.<ref group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Appendix 4: Syntax Diagrams, pp. 171–180</ref>

== דוגמאות ==
=== שלום, עולם! ===
<syntaxhighlight lang="modula2" line="1">
MODULE HelloWorld
    IMPORT InOut;
BEGIN
    InOut.WriteString("Hello, world!");
    InOut.WriteLn;
END HelloWorld.
</syntaxhighlight>

=== מחלק משותף מרבי ===

הדוגמה הבאה מוצאת את ה[[מחלק משותף מקסימלי|מחלק המשותף המריבי]] בין המונה <code>a</code> למכנה <code>b</code> ב[[שבר פשוט]] שהמשתמש קולט לתוכם, ואז מדפיסה אותו ב[[מסוף מחשב|מסוף]].<ref name=":12guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], A First Example, pp. 11–13</ref>
<syntaxhighlight lang="modula2" line="1">
MODULE GCD
    FROM InOut IMPORT ReadInt, WriteString, WriteLn, WriteInt;
    VAR a, b: INTEGER;
BEGIN
    WriteString("a = "); ReadInt(a); WriteLn;
    WriteString("b = "); ReadInt(b); WriteLn;
    WHILE a # b DO
        IF a > b THEN
            a := a - b
        ELSE
            b := b - a
        END
    END;
    WriteString("GCD = ");
    WriteInt(a, 6);
    WriteLn;
END GCD.
</syntaxhighlight>

== עיצוב ==
וירת עיצב את מודולה־2 כדי לתת מענה מקיף לכל החסרונות של [[פסקל (שפת תכנות)|פסקל]], והכתיר אותה להיות היורשת.<ref name=":1guide" group="א" /><ref name=":0report" group="ב" /> מודולה־2 היא [[שפת תכנות Low-level|שפת תכנות מערכות]], ולמרות זאת, ה[[מודולריות (תכנות)|מודלריות]] שלה מאפשרת לתוכניות לעבור [[מהדר|הידור]] מוצלח בלי שינויים נוספים עבור [[ארכיטקטורות מחשבים]] שונות, מכיוון ש[[יישום]] השפה (ה[[מהדר]] וה[[מודול (תוכנה)|מודולים]] שלו) דואג לספק מודולים מערכתיים עם [[ממשק תכנות יישומים|ממשק]] זהה ויישום מותאם לכל ארכיטקטורה שהוא מכיר בה. מודולים מערכתיים אלה עוברים הידור נפרד ובלתי־תלוי בשאר התוכנית של המשתמש. אחריות זו מוטלת על יישום השפה.<ref name=":0report" group="ב" /> חידושיה המרכזיים של מודולה־2 על פני [[פסקל (שפת תכנות)|פסקל]] הם:

# [[מודול (תוכנה)|פִּירְקָן]]<ref>{{קישור כללי|כתובת=https://terms.hebrew-academy.org.il/munnah/53690_2|כותרת=פִּרְקָן|אתר=האקדמיה ללשון העברית|תאריך_וידוא=2020-11-14}}</ref> (או {{מונחון|מוֹדוּל|module}}) כיחידת [[קוד מקור]] שעוברת [[הידור]] נפרד משאר הקוד.<ref name=":1guide" group="א" /><ref name=":0report" group="ב" />
# [[תחביר]] חינוכי ואחיד שמעודד את למידת השפה תוך כדי הקריאה.<ref name=":1guide" group="א" /><ref name=":0report" group="ב" />
# [[קו-רוטינה|שִׁגְרַת הֶמְשֵׁךְ]] {{אנ|Coroutine}}<ref>{{קישור כללי|כתובת=https://terms.hebrew-academy.org.il/munnah/78238_2|כותרת=שִׁגְרַת הֶמְשֵׁךְ|אתר=האקדמיה ללשון העברית|תאריך_וידוא=2020-11-14}}</ref> (או {{מונחון|קוֹ־רוּטִינַה|coroutine}}) כמנגנון ליישום וניהול [[שגרה (תכנות)|תהליכים]] [[בו-זמניות (מדעי המחשב)|בו־זמניים]] {{אנ|Concurrent computing}}.<ref>{{קישור כללי|כתובת=https://terms.hebrew-academy.org.il/munnah/65528_1|כותרת=בּוֹ־זְמַנִּי|אתר=האקדמיה ללשון העברית|תאריך_וידוא=2020-11-14}}</ref><ref name=":1guide" group="א" /><ref name=":0report" group="ב" />
# גישה ל[[מבנה נתונים|מבני נתונים]] ללא אכיפת [[טיפוסיות]] ב[[שפת תכנות Low-level|תכנות מערכות]]. זה שימוש בעיקר לפיתוח [[מערכת הפעלה|מערכת ההפעלה]] של [[DISER Lilith]].<ref name=":1guide" group="א" />

=== תחום הכרזה ===
כמו [[תכנות אימפרטיבי|שפות אימפרטיביות]] אחרות, גם מודולה־2 משתמשת ב[[תחום הכרזה]] לקסיקלי. כלומר, שמות משתנים חייבים להיות מוכרזים לפני השימוש בהם באותו התחום.<ref name=":12guide" group="א" /><ref group="ב">[[מודולה-2#Report|Report]], Declarations and Scope Rules, pp. 135–136</ref> בנוסף, על מנת להשתמש במשתנה בביטוי, חייבים להקצות לו ערך כלשהו.<ref name=":3guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Statements and Expressions, pp. 19–21</ref>

=== טיפוסי נתונים ===
מודולה־2 מכירה בשישה [[טיפוס נתונים|טיפוסי נתונים]] {{מונחון|בסיסיים|אותם המדריך מכנה כ־”standard types“}}: [[מספר שלם]], [[מספר טבעי]], [[מספר ממשי]], [[בוליאני]] {{אנ|Boolean data type}} (אמת או שקר), [[תו (מחשב)|תו]], ו[[מערך ביטים]] {{אנ|Bit array}}.<ref name=":2guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Elementary Data Types, pp. 28–35</ref> לא ניתן לשנות טיפוס של משתנה לאחר הכרזתו, וניסיון להקצות ערך שאינו הולם את טיפוסיות המשתנה יגרום לשגיאת [[מהדר|הידור]] עוד לפני הריצה של התוכנית.<ref name=":2guide" group="א" /> אי לכך, מודולה־2 היא שפת תכנות עם [[טיפוסיות]] חזקה וסטטית. בנוסף, טיפוס הנתונים של המשתנה מגדיר את הפעולות האפשריות עליו.<ref name=":2guide" group="א" /> מודולה־2 מאפשרת ל[[מתכנת]] להגדיר הרכבות של טיפוסי נתונים מתקדמים יותר בעזרת ששת הטיפוסים הבסיסיים.<ref name=":2guide" group="א" /> לא רק משתנים נושאים עימם טיפוסיות, אלא גם [[קבוע (תכנות)|קבועים]], [[שגרה (תכנות)|פונקציות]], ותוצאות של [[אופרטור (תכנות)|פעולות]].<ref name=":2guide" group="א" /> בנוסף, מודולה־2 לא מבצעת המרת טיפוסים בלי הוראה מפורשת. לדוגמה, פעולת חשבון בין מספר טבעי ומספר ממשי תדרוש המרה מפורשת של אחד מהם לטיפוס של האחר בעזרת <code>FLOAT(n)</code> או <code>TRUNC(x)</code>.<ref name=":2guide" group="א" />
{| class="wikitable mw-collapsible"
|+טיפוסי הנתונים הבסיסיים של מודולה־2<ref name=":2guide" group="א" /><ref name=":5report" group="ב">[[מודולה-2#Report|Report]], Basic Types, pp. 137</ref><ref name=":2">{{קישור כללי|כתובת=https://www.modula2.org/sb/env/index75.htm|כותרת=Modula-2 Basic Data Types|אתר=ADW Modula-2|תאריך_וידוא=2021-04-30}}</ref><ref>{{צ-ספר|מחבר=Niklaus Wirth, et al.|שם=MacMETH User Manual|מקום הוצאה=Zurich|מו"ל=ETH Zurich|שנת הוצאה=1992|קישור=https://www.sysecol2.ethz.ch/RAMSES/Documents/MacMETH_Manual.pdf|שפה=en}}</ref>
!סיווג
!שם
!פעולות
![[בית (מחשב)|בתים]]
!טווח ערכים מותר
|-
| rowspan="2" |'''[[מספר שלם]]'''
|<code>INTEGER</code>
| rowspan="4" |[[חיבור]] <code>+</code>, [[חיסור]] <code>-</code>, [[כפל]] <code>*</code>, [[חילוק]] שלמים <code>DIV</code>,{{ביאור|חילוק מסוג זה לא מחזיר שבר עשרוני, אלא את מספר הפעמים המרבי שהמכנה יכול להיכנס בתוך המונה בלי שארית.}} ושארית <code>MOD</code>.{{ביאור|זאת השארית שנאבדת בחילוק שלמים.}}
|2
|<math>-2^{15} \leq n \in \mathbb{Z} \leq 2^{15}-1</math>
|-
|<code>LONGINT</code>
|4
|<math>-2^{31} \leq n \in \mathbb{Z} \leq 2^{31}-1</math>
|-
| rowspan="2" |'''[[מספר טבעי]]'''{{ביאור|מספרים טבעיים כולל אפס.}}
|<code>CARDINAL</code>
|2
|<math>0 \leq n \in \mathbb{N} \leq 2^{16}-1</math>
|-
|<code>LONGCARD</code>
|4
|<math>0 \leq n \in \mathbb{N} \leq 2^{32}-1</math>
|-
| rowspan="2" |'''[[מספר ממשי]]'''
|<code>REAL</code>
| rowspan="2" |[[ארבע פעולות החשבון|ארבע פעולות חשבון]]: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>.
|4
|<math>8.43 \times 10^{-37} \leq x \in \mathbb{R} \leq 3.37 \times 10^{38}</math>{{ביאור|בפועל ערך עם [[נקודה צפה]] ודיוק עשרוני משתנה. לטיפוס שתי הצגות, ב[[נקודה עשרונית]] וב[[כתיב מדעי]] (ראה ”רצפים“ בפרק ”תחביר“).}}
|-
|<code>LONGREAL</code>
|8
|<math>4.19 \times 10^{-307} \leq x \in \mathbb{R} \leq 1.67 \times 10^{308}</math>{{ביאור|מהדרים שונים מציעים טווח שונה. הטווח הזה לקוח מ־ADW Modula-2.}}
|-
|'''[[בוליאני]]'''
|<code>BOOLEAN</code>
|[[לא (לוגיקה)|שלילה]] <code>NOT</code> (או <code>~</code>), [[וגם (לוגיקה)|וגם]] <code>AND</code> (או <code>&</code>), [[או (לוגיקה)|ואו]] <code>OR</code>.
|1
|<code>TRUE</code> או <code>FALSE</code>
|-
| rowspan="2" |[[תו (מחשב)|'''תו''']]
| rowspan="2" |<code>CHAR</code>
| rowspan="2" |להמיר תו למספר סידורי <code>ORD("c")</code>, להמיר מספר סידורי לתו <code>CHR(n)</code>.
|1
|במקור תו [[ASCII]].
|-
|2
|מהדרים חדשים מציעים [[Unicode]].
|-
|'''[[מערך ביטים]]'''
|<code>BITSET</code>
|[[איחוד (מתמטיקה)|איחוד]] <code>+</code>, [[הפרש (תורת הקבוצות)|הפרש]] <code>-</code>, [[חיתוך (מתמטיקה)|חיתוך]] <code>*</code>, ו[[הפרש סימטרי]] <code>/</code>.
|2
|מערך ערכי <code>CARDINAL</code> מ־0 עד 15.
|}
{{ביאורים}}

=== מודלריות ===
אחד מחידושיה המרכזיים של מודולה־2 הוא פיצול התוכנית ל[[מודולריות (תכנות)|מודולים]] כיחידות קוד מקור שעוברות [[מהדר|הידור]] נפרד.<ref name=":1guide" group="א" /><ref name=":0report" group="ב" /> במודולה־2, מודול מוגדר בשני רבדים: הכרזת הממשק, ויישום המודול.<ref name=":0report" group="ב" /> בדומה ל[[שפת C]], הכרזת הממשק של המודול נמצאת בקובץ נפרד ש[[תכנות הצהרתי|מכריז]] על השגרות הזמינות באותו מודול, על סוגי המשתנים שהן קולטות ופולטות. הכרזת המודול היא שימושית בעיקר למהדר, ואין צורך לספק אותה למשתמש התוכנית. לעומת זאת, יישום המודול עובר הידור ל[[שפת מכונה]] כי הוא מכיל בו קוד [[תכנות אימפרטיבי|אימפרטיבי]] שמתאר את אופן הפעולה והביצוע של השגרות והתכנית.<ref name=":0report" group="ב" />

== תחביר ==
התחביר של מודולה־2 מורכב מ[[פקודה (מחשב)|פקודות]] [[תכנות אימפרטיבי|אימפרטיביות]]. פקודות מופרדות בעזרת [[נקודה ופסיק]] <code>;</code>, ולעיתים קרובות הן גם מכילות [[ביטוי (מדעי המחשב)|ביטויים]] שעוברים [[חישוב (מדעי המחשב)|חישוב]]. פקודות וביטויים מורכבים מ[[ניתוח לקסיקלי|אסימונים]] שנוצרים מרצף תווי [[ASCII]]. ה[[מהדר]] מבצע בדיקת דקדוק תחבירי, ניתוח סמנטי, וניתוח לקסיקלי, ואז מתרגם פקודות ל[[שפת סף]]. אסימונים מוכרים מייצגים בין היתר [[מילה שמורה|מילים שמורות]], [[ערך (מדעי המחשב)|ערכים]], [[מחרוזת (מדעי המחשב)|מחרוזות]], הערות, מזהים (שמות של [[משתנה (תכנות)|משתנים]], [[קבוע (תכנות)|קבועים]], [[שגרה (תכנות)|שגרות]], ו[[מודול (תוכנה)|מודולים]]), [[אופרטור (תכנות)|פעולות]], ו[[פיסוק]].<ref group="ב">[[מודולה-2#Report|Report]], Syntax, p. 134</ref><ref name=":1report" group="ב">[[מודולה-2#Report|Report]], Vocabulary and Representation, pp. 134–135</ref><ref name=":22guide" group="א" />

=== אסימוני השפה ===
{| class="wikitable mw-collapsible"
|+אסימונים במודולה־2<ref name=":22guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Representation of Modula Programs, pp. 16–18</ref><ref name=":1report" group="ב" />
! colspan="3" |סיווג
!הגדרה
!דוגמה
|-
|מזהה
| colspan="2" |'''שם [[משתנה (תכנות)|משתנה]]'''
|רצף של [[תו (מחשב)|תווי]] אותיות [[אלפבית לטיני|אלף־בת לטיניות]] ו[[ספרה|סיפרות]] [[השיטה העשרונית|עשרוניות]], כשהתו הראשון מוכרח להיות אות.
|<code>i8MyPi</code>
|-
| rowspan="6" |[[ערך (מדעי המחשב)|ערך]]
| rowspan="3" |'''[[מספר שלם]]'''
|[[השיטה העשרונית|עשרוני]]
|רצף סיפרות עשרוניות.
|<code>2016</code>
|-
|[[אוקטלי]]
|רצף סיפרות עשרוניות בטווח 0–7 ותו <code>B</code> עוקב.
|<code>7B</code>
|-
|[[הקסדצימלי]]
|רצף סיפרות עשרוניות ואותיות מ־<code>A</code> עד <code>F</code> ותו <code>H</code> עוקב.
|<code>FFFFFFH</code>{{ביאור|צבע לבן בתצוגה הקסדצימלית.}}
|-
| rowspan="2" |'''[[מספר ממשי]]'''
|[[שבר עשרוני]]
|רצף סיפרות עשרוניות עם [[נקודה עשרונית]].
|<code>1.25</code>
|-
|[[כתיב מדעי]]
|רצף סיפרות עשרוניות עם נקודה עשרונית, התו <code>E</code>, סימן <code>+</code> או <code>-</code> ורצף ספרות עשרוניות נוסף.
|<code>4.0E-10</code>
|-
| colspan="2" |[[מחרוזת (מדעי המחשב)|'''מחרוזת''']]
|רצף תווים שנפתח ונסגר בתו <code>"</code>, או שנפתח ונסגר בתו <code>'</code>.
|<code>"Hello world"</code>

<code>'Hello world'</code>
|-
| rowspan="3" |תחביר
| colspan="2" |[[אופרטור (תכנות)|'''פעולה''']]
|כל הופעה של תו המייצג פעולה (ראה פעולות).
|<code>+</code>
|-
| colspan="2" |'''[[מילה שמורה]]'''
|כל רצף תווים שיוצר מילה מרשימת המילים השמורות.
|<code>IF</code>
|-
| colspan="2" |'''הערה'''
|כל רצף שנפתח ב־{{משמאל לימין|<code>(*</code>}} ונסגר ב־{{משמאל לימין|<code>*)</code>}}.
|<code>(* Comment *)</code>
|}
{{ביאורים}}

=== מילים שמורות ===
למודולה־2 קיימות ארבעים מילים שמורות.<ref name=":22guide" group="א" /><ref name=":1report" group="ב" />
<syntaxhighlight lang="modula2">
AND                     ELSIF                   LOOP                    REPEAT
ARRAY                   END                     MOD                     RETURN
BEGIN                   EXIT                    MODULE                  SET
BY                      EXPORT                  NOT                     THEN
CASE                    FOR                     OF                      TO
CONST                   FROM                    FOR                     TYPE
DEFINITION              IF                      POINTER                 UNTIL
DIV                     IMPLEMENTATION          PROCEDURE               VAR
DEFINITION              IMPORT                  QUALIFIED               WHILE
ELSE                    DEFINITION              RECORD                  WITH
</syntaxhighlight>

=== פקודות וביטויים ===
בדומה לשפות תכנות רבות, [[פקודה (מחשב)|פקודות]] במודולה־2 מאפשרות [[תכנות אימפרטיבי]] בכך שהן מורות [[בקרת זרימה]] והקצאת ביטויים לתוך משתנים, בעוד שהביטויים עצמם הם רצפים של [[אופרטור (תכנות)|פעולות]] ואופרנדים שעוברים [[חישוב (מדעי המחשב)|חישוב]] לפי [[קדימות אופרטורים|סדר פעולות מתמטי]], או סדר פעולות שהמתכנת מגדיר בעזרת סוגריים עגולים.<ref name=":3guide" group="א" /> מודולה־2 מכירה באחד־עשר סוגי פקודות:<ref name=":3guide" group="א" />

# [[הקצאה (תכנות)|הקצאה]] ([[קלט|קליטת]] [[ערך (מדעי המחשב)|ערך]] ל[[משתנה (תכנות)|משתנה]]) <code>:=</code>
# [[שגרה (תכנות)|קריאת שגרה]]
# שינוי תחום משתנים <code>WITH</code>
# שמונה פקודות ל[[בקרת זרימה]]:
## [[פקודת תנאי|תנאי]] <code>IF</code>
## מִקְרֶה<ref>{{צ-רשת|כתובת=https://terms.hebrew-academy.org.il/munnah/81583_1|כותרת=מִשְׁפַּט ”מִקְרֶה“|אתר=האקדמיה ללשון העברית}}</ref> <code>CASE</code>
## חזרה <code>RETURN</code>
## יציאה ידנית מלולאה <code>EXIT</code>
## וארבעה סוגי [[לולאה (תכנות)|לולאות]]:
### לולאה אין־סופית <code>LOOP</code>
### לולאת <code>WHILE</code>
### לולאת <code>REPEAT</code>
### לולאת <code>FOR</code>

==== קבועים ====
מודולה־2 מאפשרת למתכנת להכריז ערכים [[קבוע (תכנות)|קבועים]]. ערכים אלה אינם משתנים במהלך התוכנית, וערכם נקבע על ידי המהדר לפני הריצה של התוכנית. הכרזה של קבוע נעשית בעזרת הסימן <code>=</code>, והמילה <code>CONST</code> מאפשרת הכרזה של כמה קבועים ברצף כמו בדוגמה למטה.<ref name=":4guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Constant and Variable Declarations, p. 36</ref><ref group="ב">[[מודולה-2#Report|Report]], Constant Declarations, p. 136</ref>
<syntaxhighlight lang="modula2">
CONST PI = 3.14159;
    E = 2.71828;
    N = 16;
    M = N - 1;
</syntaxhighlight>

==== משתנים ====
הכרזה של משתנה נעשית בעזרת הסימן <code>:</code> כשמשמאל שם המשתנה, ומימין טיפוס המשתנה. בדומה לקבועים, ניתן להכריז מספר משתנים ברצף בעזרת המילה <code>VAR</code>.<ref name=":4guide" group="א" />
<syntaxhighlight lang="modula2">
VAR i, j, k: INTEGER;
    x, y, z: REAL;
    c: CHAR;
</syntaxhighlight>

=== בקרת זרימה ===
מהיותה [[תכנות מובנה|שפת תכנות מבנית]], חלק מסוגי הפקודות יכולות להכיל בתוכן תת־פקודות. לדוגמה, תנאי <code>IF</code> יכול להיות מוכל בתוך תנאי <code>IF</code> אחר, שגם הוא יכול להיות מוכל בתוך לולאת <code>WHILE</code>, וכך בעצם נוצרת [[בקרת זרימה]].<ref name=":3guide" group="א" /> במודולה־2, הסימן [[נקודה ופסיק]] <code>;</code> הוא מפריד בין פקודות ומגדיר את סדר הביצוע בתוכנית.<ref name=":3guide" group="א" />

===== לולאות =====
מודולה־2 מציעה ארבעה סוגי [[לולאה (תכנות)|לולאות]]: <code>LOOP</code>, <code>WHILE</code>, <code>REPEAT</code>, ו־<code>FOR</code>.<ref name=":0guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Control Structures, pp. 22–27</ref> כמו בשפות אחרות, הלולאות <code>WHILE</code>, <code>REPEAT</code>, ו־<code>FOR</code> הן תלויות בתנאי כלשהו.<ref name=":0guide" group="א" /> לעומת זאת, הלולאה <code>LOOP</code> היא אין־סופית ומתקיימת ללא תנאים. לכן, היא דורשת יציאה ידנית באמצעות הפקודה <code>EXIT</code> בתוכה.<ref name=":6report" group="ב">[[מודולה-2#Report|Report]], Loop Statements, p. 147</ref><ref name=":0guide" group="א" /> ובכל אופן, הפקודה <code>EXIT</code> יודעת לעצור לולאה מכל סוג.<ref name=":3report" group="ב">[[מודולה-2#Report|Report]], Return and Exit Statements, pp. 147–148</ref> דוגמה ללולאת <code>LOOP</code>:<ref name=":0guide" group="א" /><ref name=":6report" group="ב" />
<syntaxhighlight lang="modula2">
LOOP
    IF i < n THEN
        i := i + 1
    ELSE
        EXIT
    END
END
</syntaxhighlight>
בלולאת <code>WHILE</code>, כל עוד התנאי מתקיים, הלולאה תמשיך לחזור על עצמה. דוגמה ללולאת <code>WHILE</code>:<ref name=":0guide" group="א" /><ref name=":7report" group="ב">[[מודולה-2#Report|Report]], While Statements, pp. 145–146</ref>
<syntaxhighlight lang="modula2">
WHILE i < n DO
    i := i + 1
END
</syntaxhighlight>
בלולאת <code>REPEAT</code>, הבדיקה נעשית בסוף המחזור, והמחזור הראשון מתקיים ללא תנאי. התנאי לעצירה צריך להתקיים על מנת שהלולאה תיעצר. דוגמה ללולאת <code>REPEAT</code>:<ref name=":0guide" group="א" /><ref name=":8report" group="ב">[[מודולה-2#Report|Report]], Repeat Statements, p. 146</ref>
<syntaxhighlight lang="modula2">
REPEAT
    i := i + 1
UNTIL i = n
</syntaxhighlight>
בלולאת <code>FOR</code> ישנה הכרזה של משתנה ייעודי. [[ברירת מחדל|ברירת המחדל]], הלולאה מקדמת את המשתנה שלה ב־1 כל מחזור, אבל אפשר להגדיר את קצב ההתקדמות או להפוך אותה להתקדמות שלילית בעזרת <code>BY</code> בפקודת <code>FOR</code>:<ref name=":5guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], The Data Structure Array, pp. 37–46</ref><ref name=":9report" group="ב">[[מודולה-2#Report|Report]], For Statements, pp. 146–147</ref>
<syntaxhighlight lang="modula2">
FOR i := 0 TO -n BY -1 DO
    (* Statements *)
END
</syntaxhighlight>
===== תנאים =====
במודולה־2, הפקודה <code>IF</code> מאפשרת בקרת זרימה לפי תנאים. אם התנאי הראשון נכשל, ניתן לשרשר מספר תנאים נוספים אחריו בעזרת <code>ELSIF</code>, ומצב ברירת מחדל באמצעות <code>ELSE</code>.<ref group="ב">[[מודולה-2#Report|Report]], If Statements, p. 145</ref><ref name=":0guide" group="א" /> חשוב לציין שבשרשרת תנאים הבדיקה היא לפי סדר הופעתם. לכן, ברגע שתנאי אחד מתקיים, כל השאר אחריו מדולגים.<ref name=":0guide" group="א" /> תחביר של תנאי מלא יראה כך:
<syntaxhighlight lang="modula2">
IF n = 0 THEN
    (* n equals 0 *)
ELSIF n = 1 THEN
    (* n equals 1 *)
ELSIF n > 1 THEN
    (* n is greater than 1 *)
ELSE
    (* n is lesser than 0 *)
END
</syntaxhighlight>

=== מבני נתונים ===
מודולה־2 מציעה שמונה סוגים בסיסיים של [[טיפוס נתונים|טיפוסי נתונים]]:

# [[ערך (מדעי המחשב)|טיפוס ערך]] (לדוגמה, משתנה המחזיק בו ערך של [[מספר ממשי]])<ref name=":5report" group="ב" /><ref name=":2" />
# {{מונחון|טיפוס נמנים|טיפוס נמנים|enumeration type}} {{אנ|Enumerated type}}<ref name=":0hebrew" /><ref name=":6guide" group="א" /><ref name=":10report" group="ב" />
# {{מונחון|טווח משנה (תכנות)|טווח משנה|באנגלית: ”subrange“; ניתן לתרגם גם כ”תת־טווח“}}<ref name=":11report" group="ב">[[מודולה-2#Report|Report]], Subrange Types, pp. 137–138</ref>
# [[מערך (מבנה נתונים)|מערך]]<ref name=":5guide" group="א" /><ref name=":2report" group="ב">[[מודולה-2#Report|Report]], Array Types, p. 138</ref>
# [[רשומה (אחסון נתונים)|רשומה]]<ref>{{קישור כללי|כתובת=https://terms.hebrew-academy.org.il/munnah/6018_1|כותרת=רְשׁוּמָה|אתר=האקדמיה ללשון העברית}}</ref><ref name=":12report" group="ב">[[מודולה-2#Report|Report]], Record Types, pp. 138–139</ref>
# [[קבוצה (מבנה נתונים)|קבוצה]] (דומה למושג [[קבוצה (מתמטיקה)|קבוצה]] במתמטיקה)<ref group="ב">[[מודולה-2#Report|Report]], Set Types, p. 139</ref>
# [[מצביע]]<ref group="ב">[[מודולה-2#Report|Report]], Pointer Types, p. 140</ref>
# [[טיפוס פונקציה]] {{אנ|Function type}} (טיפוס נתונים שיודע להחזיק בו כתובת של פונקציה או [[שגרה (תכנות)|שגרה]] באופן דומה ל[[תכנות פונקציונלי]])<ref group="ב">[[מודולה-2#Report|Report]], Procedure Types, p. 140</ref><ref>{{קישור כללי|כתובת=https://www.modula2.org/reference/proceduretypes.php|כותרת=Procedure Types|אתר=ADW Modula-2|תאריך_וידוא=2021-08-08}}</ref>

בעזרת הטיפוסים הבסיסיים בשפה ניתן להרכיב טיפוסי נתונים חדשים עבור מבני נתונים מורכבים יותר כגון מערך דו־ממדי. לאחר הכרזת הטיפוסים החדשים ניתן להמשיך להרכיב בעזרתם טיפוסים מורכבים אף יותר.<ref group="ב">[[מודולה-2#Report|Report]], Type Declarations, pp. 136–140</ref>

==== מערכים ====
באופן דומה להכרזת משתנים, הכרזת [[מערך (מבנה נתונים)|מערכים]] תיעשה בעזרת המילה <code>ARRAY</code>, טווח האיברים מוגדר בעזרת שתי נקודות <code>..</code> בין סוגריים מרובעים, וטיפוסיות האיברים תבוא בסוף הפקודה אחרי המילה <code>OF</code>.<ref name=":5guide" group="א" /><ref name=":2report" group="ב" /> גישה למערכים נעשית בעזרת סוגריים מרובעים <code>A[i]</code>, ובמערכים רב־ממדיים מפרידים בין הממדים בעזרת פסיק <code>,</code>: <code>A[i, j]</code>.<ref name=":5guide" group="א" /><ref name=":2report" group="ב" /> שלא כמו בשפות אחרות, הקצאה בין משתנים שמחזיקים מערכים היא בפועל מעתיקה את המערך בינם ולא רק את המצביע. מתכנת מתחיל היה עושה זאת בעזרת לולאה, ומעתיק איבר־איבר, אך במודולה־2 מספיק להקצות את כל המערך למשתנה חדש, והוא למעשה יוצר מערך נפרד עם אותם איברים.<ref name=":5guide" group="א" />
<syntaxhighlight lang="modula2">
VAR A: ARRAY [0 .. N-1] OF INTEGER;
</syntaxhighlight>
במודולה־2 אפשר להכריז על מערכים רב־ממדיים לאיברים מאותו טיפוס בעזרת שני תחבירים:<ref name=":5guide" group="א" />
<syntaxhighlight lang="modula2">
VAR A: ARRAY [1 .. N], [1 .. M] OF INTEGER;
</syntaxhighlight>
<syntaxhighlight lang="modula2">
VAR A: ARRAY [1 .. N] OF
       ARRAY [1 .. M] OF INTEGER;
</syntaxhighlight>
==== טיפוסי נמנים ====

במודולה־2 ניתן להגדיר {{מונחון|טיפוס נמנים|טיפוס נמנים|enumeration type}} {{אנ|Enumerated type}}<ref name=":0hebrew">{{קישור כללי|כתובת=https://terms.hebrew-academy.org.il/munnah/101827_1|כותרת=טִיפּוּס נִמְנִים|אתר=האקדמיה ללשון העברית}}</ref> בעזרת רשימת מזהים בסוגריים עגולים.<ref name=":6guide" group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Enumeration Types, p. 64</ref><ref name=":10report" group="ב">[[מודולה-2#Report|Report]], Enumerations, p. 137</ref> בדומה לטיפוס התו (<code>CHAR</code>), ניתן לבקש את המספר הסידורי של כל איבר במניה בעזרת הפונקציה <code>ORD(item)</code>.<ref name=":6guide" group="א" /> בנוסף, הטיפוס הבוליאני (<code>BOOLEAN</code>) במודולה־2 הוא [[מקרה פרטי]] של טיפוס נמנים מהצורה: <code>1=BOOLEAN = (FALSE, TRUE)</code>.<ref name=":6guide" group="א" /> השימוש בטיפוסי נמנים הוא כשאר הטיפוסים בשפה. כלומר, משתנה מאותו טיפוס נמנים יכול להכיל בו אחד מהפריטים במנייה.<ref name=":6guide" group="א" />
<syntaxhighlight lang="modula2">
TYPE messageType = (error, warning, info);
     messagePriority = (prompt, monitor, log);
     messageBell = (beep, visual, sound);
</syntaxhighlight>

==== טווח משנה ====
במודולה־2 ניתן להגדיר טיפוס נתונים חדש שמגביל את טווח הערכים המותר בטיפוס ערכי בלתי־רציף (כלומר, טיפוס מספרי שאינו מספר ממשי) או טיפוס נמנים קיים. לדוגמה, טווח משנה אופייני של [[יום עסקים|ימי עסקים]] ו[[סוף שבוע|סוף שובע]] בישראל בתוך [[שבוע|ימי השבוע]] יוגדר כך:<ref name=":11report" group="ב" />
<syntaxhighlight lang="modula2">
(* Describing working days and weekend days in Israel via enum subranges. *)
TYPE Days = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday);
     WorkingDays = Days [Sunday .. Thursday];
     WeekendDays = Days [Friday .. Saturday];
</syntaxhighlight>

==== רשומות ====
[[רשומה (אחסון נתונים)|רשומה]] היא טיפוס הנתונים הגמיש ביותר בשפה, והיא מאפשרת למתכנת להגדיר טיפוס נתונים חדש המורכב מכמה טיפוסי נתונים שונים בתוך הרשומה בעזרת ”שדות.“ שדות גם יכולים להכיל בהם רשומות באופן מקונן.<ref name=":12report" group="ב" /> בעזרת רשומות ניתן לתאר בשפה טיפוסי נתונים מגוונים הן לשימוש רב־תכליתי ומופשט כגון [[עץ בינארי]], והן לשימוש מסוים כגון פרטי לקוחות. לדוגמה, רשומה פשוטה המתארת [[ייצוג צבע במחשב|ייצוג צבע]] תוגדר בעזרת רשומה המורכבת משלושה שדות, שכל אחד מהם מכיל ערך מטיפוס טווח משנה של מספר שלם:
<syntaxhighlight lang="modula2">
(* Record type describing an RGB color. *)
TYPE Color = RECORD
    R: INTEGER [0..255];
    G: INTEGER [0..255];
    B: INTEGER [0..255];
END
</syntaxhighlight>
בנוסף, במודולה־2 ניתן להגדיר זמינות של שדות על פי הערכים שנמצאים בשאר השדות.<ref name=":12report" group="ב" /> לדוגמה, לכל אדם קיים תאריך לידה, אך רק לאדם שנפטר קיים תאריך פטירה:
<syntaxhighlight lang="modula2">
TYPE Date = RECORD
    Day: INTEGER [1..31];
    Month: INTEGER [1..12];
    Year: INTEGER;
END;
Person = RECORD
    Born: Date;
    CASE IsAlive: BOOLEAN OF
        FALSE: Died: Date;
    END;
END;
</syntaxhighlight>

=== שגרות ===

מהיותה [[תכנות פרוצדורלי|שפת תכנות פרוצדורלית]], [[מודול (תוכנה)|מודולים]] במודולה־2 עשויים להגדיר תת־תוכניות ולייצא אותם כפקודות עם שמות ייחודיים ופרמטרים. פקודות כאלה נקראות [[שגרה (תכנות)|שִגְרוֹת]] והן מוגדרות בעזרת המילה <code>PROCEDURE</code>.<ref group="א">[[מודולה-2#Programming in Modula-2|Programming in Modula-2]], Procedures, pp. 47–48</ref><ref name=":4report" group="ב">[[מודולה-2#Report|Report]], Procedure Declarations, pp. 148–150</ref><ref name=":0">{{קישור כללי|כתובת=https://www.modula2.org/reference/proceduredeclarations.php|כותרת=Procedure Declarations|אתר=Modula-2 Reference|שפה=en|תאריך_וידוא=2021-05-11}}</ref> שגרה היא בגדר ”{{מונחון|פונקציה|function procedure}}“ אם היא מחזירה ערך כלשהו, אחרת היא בגדר ”{{מונחון|ציווי|proper procedure}}.“<ref name=":4report" group="ב" /><ref name=":0" /> פונקציות מחזירת ערך בעזרת הפקודה <code>RETURN</code>.<ref name=":3report" group="ב" /> לכן, ביטויים מתייחסים אליהן כאל ערכים שטרם חושבו.<ref name=":4report" group="ב" /><ref name=":0" /> שגרות יודעות להכריז על משתנים מקומיים בקטע הפנימי שנמצא בין ה־<code>PROCEDURE</code> וה־<code>BEGIN</code>.<ref name=":4report" group="ב" /><ref name=":0" /> דוגמה ל[[פרבולה|פונקציה ריבועית]] פשוטה <math>f(x)=x^2</math> כך ש־<math>f:\R \rightarrow \R</math> (כלומר, פונקציה שמקבלת ומחזירה [[מספרים ממשיים]]):
<syntaxhighlight lang="modula2">
PROCEDURE f(x: REAL): REAL;
BEGIN
    RETURN x * x;
END f
</syntaxhighlight>
במודולה־2, הפעלת פונקציות מחייבת שימוש בסוגריים עגולים אפילו בהיעדר פרמטרים. לדוגמה,{{משמאל לימין|<code>IsWindowMinimized()</code>}}. לעומת זאת, אין צורך בכתיב עם סוגריים עגולים בציווים שלא מקבלים פרמטרים. לדוגמה, <code>MinimizeWindow</code>.<ref name=":4report" group="ב" /><ref name=":0" /> בנוסף, שגרות יודעות לקבל שני סוגים של פרמטרים: ”{{מונחון|פרמטר ערך|value parameter}},“ ו”{{מונחון|פרמטר משתנה|variable parameter}}.“ פרמטר מסוג ”משתנה“ מוכרז בעזרת המילה <code>VAR</code> לפניו, והוא בפועל [[מצביע]] למשתנה שנמצא מחוץ לתחום השגרה. לפיכך, פרמטר כזה גורם ל”תופעות לוואי“ במשתנה המקורי שנשלח אל השגרה.<ref name=":4report" group="ב" /><ref name=":0" /> דוגמה לשגרת ציווי שמבצעת העלאה בריבוע בעזרת פרמטר מסוג ”משתנה“:
<syntaxhighlight lang="modula2">
PROCEDURE Square(VAR x: REAL);
BEGIN
    x := x * x;
END Square
</syntaxhighlight>
במודולה־2 קיימות 19 שגרות בסיסיות שהן זמינות בכל חלקי הקוד. מתוכן 12 הן פונקציות ו־7 הן ציווים.<ref name=":4report" group="ב" />
{| class="wikitable mw-collapsible"
|+שגרות ופונקציות סטנדרטיות במודולה־2<ref name=":4report" group="ב" />
!סיווג
!קריאה
!משמעות
!מקבלת
!מחזירה
|-
| rowspan="11" |פונקציה
|<code>ABS(x)</code>
|[[ערך מוחלט]]
| colspan="2" |[[מספר]] (בדרך כלל [[מספר ממשי|ממשי]] או [[מספר שלם|שלם]])
|-
|<code>CAP(ch)</code>
|[[אות רישית]]
| colspan="2" |תו
|-
|<code>CHR(n)</code>
|המרת מספר סידורי לתו
|[[מספר טבעי]]
|תו
|-
|<code>FLOAT(n)</code>
|המרת מספר שלם למספר ממשי
|מספר שלם
|מספר ממשי
|-
|<code>HIGH(a)</code>
|האינדקס האחרון במערך
|[[מערך (מבנה נתונים)|מערך]]
|מספר טבעי
|-
|<code>MAX(T)</code>
|הערך המרבי מהטיפוס <code>T</code>
| colspan="2" rowspan="2" |<code>T</code>
|-
|<code>MIN(T)</code>
|הערך המזערי מהטיפוס <code>T</code>
|-
|<code>ORD(ch)</code>
|המרת תו למספר סידורי
|תו
| rowspan="2" |מספר טבעי
|-
|<code>SIZE(T)</code>
|אורך בזיכרון (במספר ה[[בית (מחשב)|בתים]]) הדרוש לערך מהטיפוס <code>T</code>
|<code>T</code>
|-
|<code>TRUNC(x)</code>
|המרת מספר ממשי למספר שלם
|מספר ממשי
|מספר שלם
|-
|<code>VAL(T, n)</code>
|החזרת הפריט ה־<code>n</code> מהטיפוס <code>T</code> (בדרך כלל [[טיפוס נמנים]]); זהה ל־<code>CHR(n)</code> אם <code>T</code> הוא <code>CHAR</code>
|<code>T</code>, מספר טבעי
|<code>T</code>
|-
| rowspan="7" |ציווי
|<code>DEC(x)</code>
|הקטנה ב־<code>1</code>; בשפות תכנות רבות קיימת הפעולה <code>--</code> במקום
| colspan="2" rowspan="4" |מספר, תו, או טיפוס נמנים
|-
|<code>DEC(x, n)</code>
|הקטנה ב־<code>n</code>; בשפות תכנות רבות קיימת הפעולה <code>-=</code> במקום
|-
|<code>INC(x)</code>
|הגדלה ב־<code>1</code>; בשפות תכנות רבות קיימת הפעולה <code>++</code> במקום
|-
|<code>INC(x, n)</code>
|הגדלה ב־<code>n</code>; בשפות תכנות רבות קיימת הפעולה <code>+=</code> במקום
|-
|<code>EXCL(s, i)</code>
| colspan="3" |הוצאת הפריט <code>i</code> מהקבוצה <code>s</code>
|-
|<code>INCL(s, i)</code>
| colspan="3" |הכללת הפריט <code>i</code> בקבוצה <code>s</code>
|-
|<code>HALT</code>
| colspan="3" |יציאה מהתוכנית (סיום ריצה)
|}

=== פעולות ===
בשונה מ[[כתיב מתמטי]], במודולה־2 שני סימוני [[אופרטור (תכנות)|פעולות]] לא יכולים לבוא זה מיד אחר זה באופן רציף, ובמקרה כזה חובה להשתמש בסוגריים כדי לבודד את סדר הפעולות. לדוגמה, <code>x * -1</code> נחשב ביטוי לא חוקי במודולה־2. במקום זאת, יש לכתוב <code>x * (-1)</code>.<ref name=":3guide" group="א" /> בנוסף, לא ניתן לרמוז על פעולת כפל בין משתנים וערכים. לדוגמה, <code>2n</code> (<math>2n</math>) נחשב ביטוי לא חוקי. במקום זאת, חובה לכתוב את הביטוי במלואו. כלומר, <code>2 * n</code>.<ref name=":3guide" group="א" />
{| class="wikitable mw-collapsible"
|+סימני פעולות במודולה־2<ref name=":7guide" group="א" /><ref>{{קישור כללי|כתובת=https://www.modula2.org/reference/operators.php|כותרת=Modula-2 Reference: Expressions: Operators|אתר=ADW Modula-2|תאריך_וידוא=2021-09-20}}</ref>
! colspan="2" |סיווג
!אופרנדים
!פעולה
! colspan="2" |סימן
|-
| rowspan="20" |[[פעולה בינארית|בינארי]]
|[[הקצאה (תורת המשחקים)|הקצאה]] ([[קלט]])
| colspan="2" |קליטת [[ערך (מדעי המחשב)|ערך]] ל[[משתנה (תכנות)|משתנה]]
|'''<code>:=</code>'''
| rowspan="2" |<math>=</math>
|-
| rowspan="9" |יוחסה ([[פלט]])
| rowspan="6" |[[מספר]]ים
|שווה ל־
|'''<code>==</code>'''
|-
|לא שווה ל־
|'''<code>#</code>'''או '''<code><></code>'''
|<math>\neq</math>
|-
|גדול מ־
|'''<code>></code>'''
|<math>></math>
|-
|קטן מ־
|'''<code><</code>'''
|<math><</math>
|-
|גדול או שווה ל־
|'''<code>>=</code>'''
|<math>\geq</math>
|-
|קטן או שווה ל־
| rowspan="2" |'''<code><=</code>'''
|<math>\leq</math>
|-
| rowspan="2" |[[קבוצה (מתמטיקה)|קבוצות]]
|מוכל ב־
|<math>\sube</math>
|-
|מכיל את
|'''<code>>=</code>'''
|<math>\supe</math>
|-
|ערך וקבוצה
|שייך ל־
|'''<code>IN</code>'''
|<math>\in</math>
|-
| rowspan="2" |[[לוגיקה]] ([[פלט]])
| rowspan="2" |[[אמת ושקר (פילוסופיה)|אמת או שקר]]
|[[וגם (לוגיקה)|וגם]]
|'''<code>&</code>''' או '''<code>AND</code>'''
|<math>\and</math>
|-
|[[או (לוגיקה)|או]]
|'''<code>OR</code>'''
|<math>\or</math>
|-
| rowspan="4" |[[פעולות החשבון|חשבון]] ([[פלט]])
| rowspan="4" |מספרים
|חיבור
|'''<code>+</code>'''
|<math>+</math>
|-
|חיסור
|'''<code>-</code>'''
|<math>-</math>
|-
|כפל
|'''<code>*</code>'''
|<math>\times</math>
|-
|חילוק
|'''<code>/</code>'''
|<math>\div</math>
|-
| rowspan="4" |חשבון קבוצות ([[פלט]])
| rowspan="4" |קבוצות
|איחוד
|'''<code>+</code>'''
|<math>\cup</math>
|-
|חיתוך
|'''<code>*</code>'''
|<math>\cap</math>
|-
|הפרש
|'''<code>-</code>'''
|<math>\smallsetminus</math>
|-
|הפרש סימטרי
|'''<code>/</code>'''
|<math>\Delta</math>
|-
| rowspan="2" |[[פעולה אונארית|אונארי]]
|[[לוגיקה]] ([[פלט]])
|[[אמת ושקר (פילוסופיה)|אמת או שקר]]
|[[לא (לוגיקה)|לא]]
|'''<code>~</code>''' או '''<code>NOT</code>'''
|<math>\neg</math>
|-
|[[פעולות החשבון|חשבון]] ([[פלט]])
|מספר
|סימן שלילי
|'''<code>-</code>'''
|<math>-</math>
|}

=== מודולים ===

תוכניות במודולה־2 בנויות מרכיבים שעוברים הידור נפרד זה אחר זה לפי קשר התלות בינם. כל רכיב כזה נכתב בקובץ נפרד, ובמונחי השפה הוא מכונה ”מודול.“ לפיכך, מבנה ה[[מודול (תוכנה)|מודול]] הוא גם השלד הבסיסי של כל קובץ קוד מקור בשפה. הקטע הבא מתאר את מבנה המודול במודולה־2.<ref name=":12guide" group="א" /> בסוף מודול תמיד מופיעה [[נקודה (פיסוק)|נקודה]].
<syntaxhighlight lang="modula2">
MODULE MyModule
    (* Import Lists *)
    (* Declarations *)
BEGIN
    (* Statements *)
END MyModule.
</syntaxhighlight>

== מהדרים ==
במשך השנים מאז הופעתה בשנת 1983 פותחו עשרות [[מהדר]]ים ו[[מימוש]]ים שונים לשפה. נכון לשנת 2021, קיימים שני מימושים מרכזיים שזמינים לציבור הרחב ונמצאים תחת פיתוח ותחזוקה מתמדת: המימוש של [[מיזם גנו]] והמימוש של ADW. כמו כן, גם מעצב השפה, [[ניקלאוס וירת]], פיתח מימוש משלו עבור השפה בין השנים 1983–1985.<ref name=":1" /><ref name=":0wirth" />

=== GNU Modula-2 ===
GNU Modula-2 הוא מימוש [[תוכנה חופשית|חופשי]] ומקיף עבור מודולה־2 עם המהדר [[GCC]] מטעם [[פרויקט גנו|מיזם גנו]].<ref name=":4">{{קישור כללי|כתובת=http://nongnu.org/gm2/12/features.html|כותרת=Features|אתר=GNU Modula-2|תאריך_וידוא=2021-09-20}}</ref><ref>{{קישור כללי|כתובת=http://nongnu.org/gm2/12/licence.html|כותרת=License|אתר=GNU Modula-2|תאריך_וידוא=2021-09-20}}</ref> הגרסה הראשונה של המימוש שוחררה לציבור בשנת 2010.<ref name=":5">{{קישור כללי|כתובת=http://nongnu.org/gm2/12/news.html|כותרת=News|אתר=GNU Modula-2|תאריך_וידוא=2021-09-20}}</ref> המהדר מצטיין במיוחד בממשק בין מודולה־2 ל[[שפת C]].<ref name=":4" /> בנוסף, המימוש [[חוצה-פלטפורמות|חוצה פלטפורמות]] ותומך גם ב[[ארכיטקטורות מחשבים]] פחות מוכרות כמו [[ARM]] ו־AVR ל[[מערכת משובצת מחשב|תכנות משובצות]].<ref name=":4" />

=== ADW Modula-2 ===
ADW Modula-2 הוא מהדר [[תוכנה חינמית|חינמי]] עבור מודולה־2.<ref name=":3" /> הגרסה הראשונה של המהדר שחוררה בשנת 2011 אחרי שירש את הפיתוח של מימוש קודם, Stony Brook Modula-2.<ref name=":3">{{קישור כללי|כתובת=https://www.modula2.org/adwm2/|כותרת=ADW Modula-2|אתר=ADW Modula-2|תאריך_וידוא=2021-09-20}}</ref> המהדר תומך אך ורק ב[[חלונות]] (32 או 64 סיביות).<ref name=":3" /> כמו כן, באתר הבית של ADW Modula-2 ניתן למצוא מדריך מקיף לשפה, דוגמאות והסברים לשימוש במהדר.<ref>{{קישור כללי|כתובת=https://www.modula2.org/index.php|כותרת=Home|אתר=ADW Modula-2|תאריך_וידוא=2021-09-20}}</ref> נכון לשנת 2021 הוא נמצא תחת פיתוח פעיל, ויוצאת לו גרסה חדשה כאחת לשנתיים.<ref name=":3" />

== ראו גם ==
* [[פסקל (שפת תכנות)|פסקל]] - שפת התכנות שממנה הורחבה מודולה־2.<ref name=":1" />
* [[עדה (שפת תכנות)|עדה]] - [[שפת תכנות עילית]] ממשפחת פסקל שפותחה במיוחד עבור [[צבא ארצות הברית]]; גם היא הושפעה מאחותה, מודולה־2.{{מקור|נושא=מדעי הרוח|נושא2=מחשוב}}
* [[לואה (שפת תכנות)|לואה]] - [[שפת תכנות דינמית]] עכשוויות וידידותית, למרות שאינה ממשפחת פסקל, היא תפסה השראה רבה ממודולה־2.<ref>{{צ-מאמר|שם=The evolution of Lua|קישור=https://doi.org/10.1145/1238844.1238846|מו"ל=Association for Computing Machinery|כתב עת=Proceedings of the third ACM SIGPLAN conference on History of programming languages|שנת הוצאה=2007-06-09|עמ=2–1–2–26|סדרה=HOPL III|doi=10.1145/1238844.1238846|מחבר=Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes}}</ref>

== לקריאה נוספת ==
{{Ltr|* {{עוגן|Programming in Modula-2|{{צ-ספר|שם=Programming in Modula-2|קישור=https://link.springer.com/book/10.1007/978-3-642-83565-0|מו"ל=Springer-Verlag|שנת הוצאה=1988|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-83567-4|מהדורה=4th Edition|מחבר=Niklaus Wirth|שפה=en}}}}
* {{עוגן|Report|{{צ-ספר|שם=Report on the Programming Language Modula-2|קישור=https://link.springer.com/content/pdf/bbm%3A978-3-642-83565-0%2F1.pdf|מו"ל=Springer-Verlag|שנת הוצאה=1988|מקום הוצאה=Berlin, Heidelberg|ISBN=978-3-642-83567-4|מהדורה=4th Edition|מחבר=Niklaus Wirth|שפה=en|עמ=133–184}}}}}}

== קישורים חיצוניים ==
* {{ויקישיתוף בשורה|שם=Modula-2}}
* {{אתר רשמי|http://www.sysecol2.ethz.ch/RAMSES/MacMETH.html|ETH Modula-2|אנגלית}}
* {{אתר רשמי|http://www.nongnu.org/gm2/homepage.html|GNU Modula-2|אנגלית}}
* {{אתר רשמי|https://www.modula2.org/|ADW Modula-2|אנגלית}}
* [https://rosettacode.org/wiki/Category:Modula-2 דגימות קוד של מודולה־2 ב־RosettaCode] (באנגלית)

== הערות שוליים ==
=== מדריך השפה מהדורה רביעית ===
{{הערות שוליים|יישור=שמאל|קבוצה=א}}

=== סקירת השפה ===
{{הערות שוליים|יישור=שמאל|קבוצה=ב}}

=== מקורות נוספים ===
{{הערות שוליים|יישור=שמאל}}

{{בקרת זהויות}}

[[קטגוריה:שפות תכנות]]