עדה (שפת תכנות)

**עָדָה** (באנגלית: **Ada**) היא שפת תכנות עילית, מובנת, אימפרטיבית, מונחת עצמים עם טיפוסיות סטטית. עדה הורחבה מפסקל ושפות אחרות. עדה תומכת בתכנות לפי חוזה, טיפוסיות חזקה מאוד, הקבלת תהליכונים, ותכנות אי דטרמיניסטי . עדה פותחה במקור על ידי מדען המחשב היהודי צרפתי   בעקבות מכרז של משרד ההגנה האמריקני על מנת להחליף מעל 450 שפות תכנות שהיו בשימוש צבאי בארצות הברית. החל מהתקן השני של עדה שהופיע ב־1995, המתכנן והמעצב המרכזי של עדה הוא מדען המחשב האמריקני .

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

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

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

### המכרז (1975–1979)
[טקסט=|ממוזער|[עדה לאבלייס|אוֹגוּסְטָה עָדָה קִינְג, רוזנת לאבְלֵייס. על שמה נקראת שפת התכנות עדה.]]
בשנת 1978 משרד ההגנה האמריקאי פרסם באופן סופי את הדרישות לעיצוב והתכנון של השפה באפיון שכונה .

ארבעה צוותים נענו למכרז, והצעותיהם כונו באופן אנונימי בארבע צבעים באנגלית: אדום, ירוק, כחול, וצהוב. באפריל 1978 רק ההצעות ירוק ואדום עלו לשלב הבא. במאי 1979, ההצעה "ירוק" בהובלת ז'אן אישביה זכתה בתחרות וקיבלה את השם **עדה** (באנגלית **Ada**) על שם הרוזנת עדה לאבלייס שנחשבת למתכנתת הראשונה בהיסטוריה. העיצוב של אישביה הושפע משפת התכנות LIS  שאישביה וצוותו פיתחו במהלך שנות ה־70.

בשנת 1979 בחודש ביוני, ACM פרסמו לראשונה מדריך ההוראות עבור שפת התכנות עדה.

### השקה (1980–1982)
בשנת 1980 בחודש יולי הופיעה ההצעה הראשונה לתקן רשמי עבור השפה. באותה שנה ב־10 בדצמבר (יום הולדתה של הרוזנת עדה), משרד ההגנה האמריקני תיקנן באופן רשמי את השפה בתקן **MIL-STD-1815** המציין את שנת הלידה (1815) של הרוזנת עדה לאבלייס במספר התקן.

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

#### דעת קהל
עדה משכה תשומת לב בקרב מתכנתים רבים בתחילת דרכה. תומכיה ואחרים טענו שעם הזמן היא תהפוך לשפה פופולרית גם בשימוש כללי למטרות אזרחיות. אישביה הכריז אז שבתוך עשור תהיינה רק שתי שפות שתשרודנה והן עדה ו־Lisp. לעומת זאת, בקובץ הז'ארגון של מונחי ההאקרים שהצטבר מהשנים 1975–1983 תוארה השפה באותם ימים בקרב האקרים כך:היא בדיוק מה שכל אחד היה יכול לצפות - שפה שאושרה בפקודה, עוצבה על ידי ועדה, קשה לשימוש, ובאופן כללי גרמה לבזבוז מיותר של הון עתק. [...] עדה לאבלייס בוודאי הייתה מחווירה מהשימוש שנעשה בשמה.

### עדה 1983 (1983–1994)
החל משנת 1983 עדה נכנסה לשימוש צבאי בארצות הברית ובצבאות נאט"ו וחברות אזרחיות נאלצו לתכנת עם השפה כל רכיב חומרה או תוכנה שנועדו לשימוש צבאי בארצות הברית, אך הדרישה נזנחה עם השנים עקב מחסור במתכנתי עדה.

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

בשנת 1983 אושר היישום החוקי הראשון של עדה שעמד במבחן האימות וכל התקנים: NYU Ada/Ed Translator (כיום מכונה GNAT). היישום פותח באוניברסיטת ניו יורק. המהדר פותח בשפת התכנות SETL  שהייתה מבוססת על תורת הקבוצות במתמטיקה ופותחה גם היא באוניברסיטת ניו יורק.

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

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

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

### שימוש צבאי
[טקסט=F-22 ראפטור|ממוזער|ה[חמקנות|חמקן האמריקני F-22 מתוכנת בעדה.]]עדה ראתה שימוש צבאי נרחב ברכיבי חומרה ותוכנה בין היתר עבור חמקנים, מפציצים, מטוסי קרב, מסוקי קרב, כטב"מים, כלי שריון, צוללות, מערכות מכ"ם, ולוחמה אלקטרונית במדינות נאט"ו ובמיוחד בארצות הברית.

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

## דוגמאות
### שלום עולם!

```ada
with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
begin
    Put_Line ("Hello world!");
end Main;
```


### [[מחלק משותף מקסימלי]]
חלק האפיון:
```ada
package GCD_Example is
	function GCD (A, B : Integer) return Integer;
end GCD_Example;
```
חלק המימוש:
```ada
package body GCD_Example is
	function GCD (A, B : Integer) return Integer is
		M : Integer := A;
		N : Integer := B;
		R : Integer;
	begin
		if N = 0 then
			return abs M;
		elsif M = 0 then
			return abs N;
		end if;
		R := M mod N;
		while R /= 0 loop
			M := N;
			N := R;
			R := M mod N;
		end loop;
		return abs N;
	end GCD;
end GCD_Example;
```


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

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

### מודולריות
כמו תוכניות במודולה-2, שפה שנתנה השראה לעדה, תוכניות בעדה הן מודולריות, וכל יחידת קוד מקור בתוכנית עוברת הידור נפרד. בעדה קיימים ארבעה סוגי יחידות קוד בסיסיים: , , , ו. שגרות מכילות קוד אימפרטיבי עם פקודות לביצוע, או קוד פונקציונלי שמוביל לחישוב של ביטוי.  הן יחידות שמכילות הגדרות של עצמים ונתונים, כגון טיפוסים. כמו כן, חבילות יכולות להכיל גם תת-תוכניות.  הן יחידות שמגדירות אוסף תהליכים שניתן לבצע באופן בו זמני עם משימות אחרות. יחידות מוגנות הן יחידות להגדרת פעולות לשימוש מתואם בנתונים בין משימות, מכיוון שמשימות רצות באופן בו-זמני. באופן דומה לשפות כמו C++, כל יחידה בעדה היא מורכבת משני רבדים: , ו. רובד האפיון מכיל קוד הכרזתי בלבד על מה שיש ליחידה להציע לשאר התוכנית, ועל מה שצפוי מהמימוש של אותה יחידה. רובד זה חשוף ליחידות בתוכנה. לעומת זאת, רובד המימוש ממש את רובד האפיון, הוא פרטי ליחידה ואינו חשוף לשאר התוכנית. כמו כן, עדה מפצלת גם בכל יחידת קוד בין החלק ההצהרתי (הכרזות על משתנים וכדומה) והחלק הביצועי (פקודות, בקרת זרימה וכדומה). הפיצול בין ארבעת סוגי היחידות וכמו כן בין האפיון למימוש בכל יחידה מאפשר לצוותים ומתכנתים שונים לעבוד באופן נפרד ומקביל על חלקים שונים של התוכנית.

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

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

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

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

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

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

#  - פקודה שמקצה ערך חדש למשתנה כלשהו.
#  - פקודת בקרת זרימה בו כל האפשרויות מותנות בתוצאה של אותו הערך.
#  - פקודת בקרת זרימה על פי תנאי של ערך אמת או שקר.
#  - פקודת בקרת זרימה לחזרה על רצף פקודות. לולאה עוצרת עם באמצעות פקודת יציאה.
#  - בתחום הכרזה ניתן להכריז על משתנים מקומיים שאינם נגישים מחוץ לו.
#  - פקודה זמינה רק למשימות. מעכבת את המשך ביצוע המשימה לפי זמן מוקצב מראש.
#  - פקודה זמינה רק למשימות. מעכבת את המשך ביצוע המשימה עד שמשימה אחרת גם פוגשת את אותה פקודת המתנה. לאחר מכן שתי המשימות יכולות להמשיך.

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

### טיפוסיות
עדה היא שפה עם טיפוסיות סטטית וחזקה. לפיכך, כל עצם בשפה מסווג לפי טיפוס כלשהו. טיפוסים בעדה מסווגים לשתי קטגוריות:  ו. טיפוסים יסודיים כוללים , , ו. טיפוסים מורכבים כוללים בין היתר רשומות, מערכים, ממשקים, ומשימות.  מגדיר מראש קבוצת ערכים מספריים עם מזהים ששייכים לו. לדוגמה, טיפוס בוליאני (`Boolean`) וטיפוס תו (`Character`) הם טיפוסי נמנים בעדה. בעדה מוגדרים מראש טיפוסים מספריים בסיסיים: טיפוס מספר שלם (`Integer`), טיפוס נקודה צפה (`Float`), וטיפוס אורך זמן (`Duration`). הטיפוסים מספר חיובי (`Positive`) ומספר טבעי (`Natural`) הם  של טיפוס המספר השלם (`Integer`) בעדה כשמאולץ עליהם טווח שונה. טיפוס אורך זמן, לעומת זאת, מוגדר כטיפוס נקודה קבועה עם דיוק של `0.000000001` בשנייה. בעדה ניתן להגדיר גם  על טיפוסים. לדוגמה, טיפוס מספרים טבעיים יהיה תת-טיפוס של מספרים שלמים עם  על  הערכים המותר שלו.  בעדה מתנהג באופן דומה למצביע בשפות אחרות.  הוא ייצוג של טיפוס אחר, ונועד כדי לחשוף רק חלקים מסוימים מהטיפוס המקורי. בעדה ניתן להגדיר טיפוסים סוגניים. בעדה ניתן לעשות שימוש גם בטיפוס נקודה קבועה, אך חובה להכריז על טיפוס כזה ולהגדיר את מידת הדיוק שלו בהתאם לשימוש הנדרש. לפיכך עדה לא מספקת טיפוס מוכן מראש לנקודה קבועה. בטיפוסי , ניתן להרכיז על , שהם מתנהגים באופן דומה ל ברשומה. באמצעותם ניתן להתנות או לאפיין את המרכיבים בתוך הרשומה.

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

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

### בקרת זרימה
פרמטר של לולאה בעדה הוא תמיד קבוע בתוך הלולאה לכל מחזור.

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

### קלט ופלט
הספרייה הסטנדרטית של עדה מספקת שגרות וטיפוסים מיוחדים עבור קלט ופלט.

### תכונות
בעדה, מאפיינים שהמהדר מספק את המידע שלהם אודות עצמים שונים וטיפוסים בתוכנית נקראים . הגישה לתכונות היא באמצעות תו מירכאה בודד `'`. לדגמה, `Integer'Last` ישיב את הערך הגדול ביותר שניתן להכניס במשתנה מסוג `Integer`. חלק מהתכונות נחשבות לפונקיות, לדוגמה `Integer'Image` היא פונקציה שתקבל פרמטר מסוג `Integer` ותחזיר מחרוזת שהערך יוצג בו.

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

### אסימוני השפה
תווים חוקיים בעדה מודרנית כוללים תווי יוניקוד על פי תקן ISO 10646.  הוא שורת תווים חוקיים שיוצרים יחד אחת מהאפשריות ההבאות: , , ערך מספרי, ערך תו, ערך מחרוזת, הערה, או  (למהדר). להערות אין שום השפעה על התוכנית. תווי רווח נחשבים תמיד לתווים שמפרידים בין אסימונים, אלא אם כן הם מופיעים בתוך הערות או מחרוזות. לעומת זאת, תווי שבירת שורה נחשבים בכל מצב לתווים שמפרידים בין אסימונים. בעדה מותר להוסיף אפסים מקדימים בערכים מספריים.

### מילים שמורות
בעדה לא ניתן להשתמש במילים שמורות כמזהים. בעדה 2012 קיימות 73 מילים שמורות:

### הכרזות
#### הכרזת טיפוסים
בעדה הכרזת  חדשים נעשית באמצעות המילה השמורה `type`. באופן דומה, הכרזת  חדש נעשית באמצעות המילה השמורה `subtype`. במספרים שלמים, ניתן להגדיר טיפוס נגזר בקיצור באמצעות טווח בלבד, ללא שימוש במילה השמורה `new`.

#### הכרזת טיפוס נמנים
בעדה  מוגדר באמצעות רשימת מזהים חוקיים, או באמצעות רשימת ערכי תווים.
```ada
type Color_Format is (RGB, HSV, HSL);
```


#### הכרזת טיפוסי נקודה קבועה
בעדה ניתן להכריז על טיפוס נקודה קבועה באמצעות המילה השמורה `delta`. בניגוד לנקודה צפה, טיפוסים אלה שומרים על דיוק קבוע לפי הערך הקטן ביותר שמוגדר באמצעות `delta`.
```ada
type Fixed_Point_Radian is delta 0.00001 range 0.0 .. 2.0 * Ada.Numerics.Pi;
```


#### הכרזת משתנים
בעדה מכריזים על משתנים באמצעות שם המשתנה והטיפוסיות שלו לאחריו, ומותר להכריז על מספר משתנים מאותו טיפוס באותה פקודה.
```ada
RGB_Magenta : Colors.RGB_Color
```


#### הגדרת טווח בטיפוסים מספריים
בהכרזת תת-טיפוס, טיפוסים נגזרים, ובהכרזת משתנים עם ערכים מספריים, עדה מאפשרת להגדיר טווח באמצעות המילה השמורה `range`.
```ada
R, G, B: Integer range 0 .. 255 := 0;
```

#### אדגום עצמים
לאחר הכרזה, ניתן  את העצם, איך אין חובה לעשות זאת אלא אם כן זהו קבוע. אדגום של  ב נעשה בעדה באמצעות . דוגמה לאדגום של צבע מסוים:
```ada
RGB_Magenta : Colors.RGB_Color := (255, 0, 255);
```
קבוע לעצמים מוכרז באמצעות המילה השמורה `constant` לפני הטיפוס.
```ada
RGB_Magenta : constant Colors.RGB_Color := (255, 0, 255);
```

#### מספרים קבועים
בעדה ניתן להכריז על מספרים קבועים חדשים באמצעות המילה השמורה `constant` ללא הטיפוסיות של המספר.
```ada
Pi : constant := 3.14159;
```


#### הכרזת מערכים וטיפוסי מערך
הכרזת מערכים בעדה יכולה להיות בזמן הכרזת משתנה כמו בשפות תכנות רבות, או באמצעות הכרזת טיפוס מערך לשימוש חוזר. כמו כן, עדה מאפשרת להכריז על מערכים רב-ממדיים באותה צורה עם הפרדה של פסיק `,` בין הטווחים, ולהכריז על טווח פתוח באמצעות הערך `<>` בטווח. בטיפוסי מערכים עם טווח פתוח, ניתן להכריז על שימוש עם טווח סגור באדגום. בנוסף, ניתן ל טיפוסי מערך בתוך חבילות סוגניות. לדוגמה, במישורים, לטיפוס מערך כמו וקטור יהיו רק שני ערכים, אבל במרחבים, לאותו הטיפוס יהיו שלושה ערכים. דוגמה להכרזה על טיפוס מערך וקטור סוגני:
```ada
type Vector is array (Natural range 1 .. Dimension) of Float;
```


#### הכרזת רשומות
הכרזת רשומות בעדה נעשית באמצעות המילה השמורה `record`. המרכיבים של הרשומה לא חייבים להיות מאותו טיפוס. וכל מרכיב יכול להגדיר לעצמו טווח שונה.
```ada
type RGB_Color is record
    R, G, B : Integer range 1 .. 255;
end record;
```


#### מבחינים
בעדה ניתן להכריז על פרמטרים לטיפוסים מורכבים באמצעות . לא ניתן להכריז על מבחינים בטיפוס מערך או בטיפוס ממשק. הכרזת מבחינים נעשית לצד שם הטיפוס. יישום ההבחנה בטיפוס יכול להיעשות בכמה דרכים, ואף באמצעות . דוגמה לטיפוס רשומה עבור ייצוג צבע שמקבל מבחין לסוג הייצוג (`RGB`, `RGBA`, `HSL`) ומציע רכיבים בהתאם באמצעות פקודת ניתוב מקרים:
```ada
package Colors is
	type Color_Format is (HSL, RGB, RGBA);
	type Color (Format : Color_Format) is record
		case Format is
			when HSL =>
				H : Integer range 0 .. 360;
				S, L : Integer range 0 .. 100;
			when RGB | RGBA =>
				R, G, B : Integer range 0 .. 255;
				case Format is
					when RGBA =>
						A : Integer range 0 .. 255;
					when others =>
						null;
				end case;
		end case;
	end record;
end Colors;
```

#### שגרות
בשגרות, ניתן להכריז על פרמטרים לקריאה בלבד באמצעות `in`.

### תכנות מונחה עצמים
תכנות מונחה עצמים בעדה נעשה באמצעות רשומות מתויגות, המסומנות עם המילה השמורה `tagged`. בדוגמה הבאה מוכרזים שלושה סוגים של מבני נתונים עבור ייצוג צבע (`RGB`, `RGBA`, `HSL`) עם הורשה ודריסת פונקציה. רובד האפיון של החבילה:
```ada
package Colors is
	-- Color
	type Color is abstract tagged null record;
	function Is_Dark (C : Color) return Boolean is abstract;
	-- HSL
	type HSL_Color is new Color with record
		H : Integer range 0 .. 360;
		S, L : Integer range 0 .. 100;
	end record;
	overriding function Is_Dark (C : HSL_Color) return Boolean;
	-- RGB
	type RGB_Color is new Color with record
		R, G, B : Integer range 0 .. 255;
	end record;
	overriding function Is_Dark (C : RGB_Color) return Boolean;
	-- RGBA
	type RGBA_Color is new RGB_Color with record
		A : Integer range 0 .. 255;
	end record;
end Colors;
```
רובד המימוש של החבילה יגדיר מימוש שונה לפונקציה `Is_Dark` עבור `HSL_Color` ו-`RGB_Color`, אבל שקול לפי הצבע. בו בזמן הטיפוס `RGBA_Color` יורש את אותה הפונקציה של `RGB_Color` לפי האפיון.
```ada
package body Colors is
	-- HSL
	overriding function Is_Dark (C : HSL_Color) return Boolean is
	begin
		return C.L < 50;
	end Is_Dark;
	-- RGB and RGBA
	overriding function Is_Dark (C : RGB_Color) return Boolean is
		Max : constant Integer := Integer'Max (C.R, Integer'Max (C.G, C.B));
		Min : constant Integer := Integer'Min (C.R, Integer'Min (C.G, C.B));
		Sum : constant Integer := Max + Min;
	begin
		return Sum < 255;
	end Is_Dark;
end Colors;
```


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

## לקריאה נוספת

* 

## קישורים חיצוניים

* 

* Ada Lovelace: a Victorian woman who traded in poems for coding, Google Arts & Culture, 2019


## הערות שוליים

קטגוריה:ערכים שבהם תבנית בריטניקה אינה מתאימה
קטגוריה:שפות תכנות
קטגוריה:שפות תכנות מונחות עצמים