APL

**APL** (מבוטא: "אֵיי־פִּי־אֶל", נקראת על פי ראשי התיבות של שם הספר שהציג אותה: "A Programming Language", בעברית: "שפת תכנות") היא שפת תכנות שפותחה בשנות ה־60 של המאה ה־20 על ידי קֶנֵת' יוג'ין אַייבֶרְסוֹן.

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

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

## היסטוריה
### הסימון המתמטי
קנת' יוג'ין אַייבֶרְסוֹן  התחיל לעבוד על סימון מתמטי חדש לפעולות על מערכים באוניברסיטת הרווארד בשנת 1957. בשנת 1960 הוא התחיל לעבוד ב־IBM, שם המשיך לפתח את הסימון החדש יחד עם אַדִין ד' פַלְקוֹף והפיץ אותו בספרו *A Programming Language* בשנת 1962. ההקדמה בספר מתארת את ייעודה של השפה כך:

בתרגום לעברית: .

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

אייברסון השתמש בסימון שלו גם בטיוטה לפרק "*A Programming Language*" בספר "*Automatic Data Processing*" שאותו חיבר יחד עם פרד ברוקס.

### המשך פיתוח הסימון לשפת תכנות
הניסיון הראשון להשתמש בסימון כדי לתאר מערכות מחשב שלמות ב־IBM התחיל בשנת 1962, אחרי שפלקוף שוחח עם ויליאם קַרְטֶר על עבודתו להגדרת סט פקודות אחיד בסדרת המחשבים שנודעה בהמשך בשם IBM System/360.

בשנת 1963 הֶרְבֶּרְט הֶלֶרְמַן, שעבד אז במכון המחקר של IBM, מימש חלק מהסימון של APL על מחשב IBM 1620. המימוש החלקי של הלרמן שימש בקורס תיכוני מיוחד שעסק בחישוב ערכי פונקציות טרנסצנדנטיות באמצעות טורים. התלמידים ניסו את הקוד שלהם במעבדתו של הלרמן. מימוש חלקי זה של הסימון נקרא אז .

ב־1963, פלקוף, אייברסון, ואדוארד ה' סַאסֶנְגוּת' ג'וניור (כולם עובדי IBM) השתמשו בסימון לתיאור פורמלי של הארכיטקטורה והפונקציונליות של סדרת המחשבים IBM System/360. עבודתם פורסמה כמאמר בכתב העת של IBM, IBM Systems Journal, בשנת 1964. לאחר פרסום המאמר, הצוות החל לעבוד על מימוש מלא של APL על מחשבי IBM.

אחרי שלורנס מ' בְּרִיד ופיליפ ס' אַבְּרַמְס מאוניברסיטת סטנפורד הצטרפו לצוות באגף המחקר של IBM, הם המשיכו את עבודתם הקודמת על מימוש חלק מהסימון בעזרת FORTRAN IV על מחשב IBM 7090 שהריץ את מערכת ההפעלה IBSYS. עבודתם הושלמה בסוף 1965 וכונתה IVSYS (קיצור ל־"Iverson System" על שם אייברסון). בסיס המימוש הוסבר בפירוט על ידי אברמס בדו"ח טכני של אוניברסיטת סטנפורד, "An Interpreter for Iverson Notation" ב־1966. ההיבט האקדמי של הפרסום היה תחת פיקוחו של ניקלאוס וירת. כמו עבודתו הקודמת של הלרמן (מערכת ה־PAT), גם מימוש זה לא כלל את מערכת הסימנים של APL, אלא השתמש במילים שמורות מהשפה האנגלית עבור כל הפונקציות והאופרטורים של APL. המערכת הותאמה בהמשך למערכות מרובות משתמשים, וב־1966 הופעלה על מחשבי IBM System/360 Model 50 ונעשה בה שימוש פנימי ב־IBM.

### חומרה
ממוזער|ראשי הדפסה של IBM הכוללים תווים עבור APL.
ממוזער|תרשים פריסת המקשים של מקלדת IBM 2741 עם ראש ההדפסה המותאם ל-APL

הפיתוח החשוב ביותר שאפשר שימוש יעיל ב-APL לפני זמינותם של מסופים מבוססי שק"ק היה פיתוח מכונת הכתיבה החשמלית של IBM (באנגלית: IBM Selectric), שנודעה בשם "כדורית". במכונה זו ניתן היה להחליף את ראש ההדפסה (הכדור, באנגלית: "Typing element" או בשפת סלנג "Typeball") הרגיל, שהכיל את התווים האלפביתיים, בראש אחר שכלל את הסימנים הנחוצים ל־APL. פיתוח זה אפשר שימוש ב-APL עם מסופים כמו IBM 1050 ו־IBM 2741 שהדפיסו את הפלט שלהם על גבי נייר. בנוסף, היה אפשר להניח מדבקות על גבי המקשים הרגילים של המקלדת כדי להציג איזה סימן כל מקש מייצג בראש ההדפסה של APL. באופן זה התאפשרו לראשונה כתיבה והדפסה של קוד APL עם הסימון המתמטי המקורי של אייברסון במקום מילות מפתח מסורבלות המייצגות אותם בשפה האנגלית. פלקוף ואייברסון הגדירו שני ראשי הדפסה עבור APL, 987 ו־988, עוד לפני המימוש של APL כתוכנת מחשב.

גם עם השימוש במכונת הכתיבה הכדורית, סימני APL רבים עדיין הודפסו בעזרת שני סימנים קיימים זה על גבי זה. לדוגמה הסימן ⍋ (ששמו *grade up*) נכתב בעזרת השימוש בסימן דלתא (shift-H) ועל גביו פס אנכי (shift-M). מצב זה היה בלתי נמנע מאחר שמספר הסימנים ב־APL היה גדול בהרבה ממספר התווים שראש ההדפסה היה יכול להכיל (88 תווים), אף שתווים אלפביתיים רגילים הוגבלו לאותיות גדולות בלבד.

### זמינות מסחרית
סביבת העבודה הראשונה של APL פותחה על ידי לארי בְּרִיד ב־1966 על מחשב IBM 1050 במעבדות IBM Mohansic Labs ליד המרכז למחקר על שם תומאס װטסון, ביתה של APL, ב־יוֹרְקטַאוֹן הַײטְס, מדינת ניו־יורק.

IBM נטלה חלק מרכזי בהשקת APL למטרות מסחריות. APL הושקה לראשונה כמוצר מסחרי בשנת 1967 עבור מחשבי IBM 1130 כ־*APL\1130*. מערכת זו דרשה זיכרון בגודל 8K מילים של 16 סיביות, בנוסף לדיסק קשיח ייעודי בגודל 1 מ"ב.

APL זכתה לפופולריות במחשבים מרכזיים מסוף שנות ה-60 עד תחילת שנות ה-80, בין השאר בגלל התמיכה בריבוי משתמשים על מחשבים עם מפרט טכני צנוע יחסית גם ללא חומרה לניהול זיכרון וירטואלי. שיפורים נוספים לביצועים של APL פותחו בהמשך לחלק ממחשבי IBM System/370 בהם נוספה תמיכה בהרצת APL בקושחה של המעבד, שנקראה *APL Assist Microcode*. שימוש בתכונה זו אפשר האצת חומרה ל־APL. משתמשי APL החלו לעבור למחשבים אישיים ולנטוש את המחשבים המרכזיים רק כאשר החומרה של מיקרו-מחשבים הגיעה לביצועים מספיקים, באמצע שנות ה־80.

מפרשי ה־APL הראשונים של IBM עבור מחשבי IBM 360 ו־IBM 370 כללו מימוש פנימי של ריבוי משתמשים במקום להישען על שיתוף המשאבים של המערכת. המפרש מרובה המשתמשים הראשון, *APL\360*, הושק ב־1966 ב־IBM. המפרש היה יכול להגדיר משתנים חדשים במערכת ההפעלה ולקבל ממנה מידע דרך פונקציות APL מיוחדות שנקראו *I-beam*.

ב־1973 השיקה IBM את *APL.SV* שהיה המשכו של אותו המוצר (APL\360) אך הפעם היא הציעה *[[משתנה (תכנות)|משתנים]] משותפים* (באנגלית: "shared variables") לשפה. תכונה חדשה זאת אפשרה תיווך קל יותר בין APL לשאר הרכיבים במערכת ההפעלה כמו מערכת הקבצים או שיתוף מידע בין תהליכים שרצים על מעבדים נפרדים במחשבים מרכזיים. בשנות ה־70, מפרש ה־APL של IBM שהיה מיועד עד אז למחשבים מרכזיים עבר התאמה למחשבים שולחניים מסוג IBM 5100, שכללו מסך שק"ק קטן ומקלדת APL, בזמן שרוב המחשבים האישיים כללו רק שפת BASIC. בשנות ה־80, המפרש *VSAPL* היה נפוץ בין משתמשי CMS, VSPC, TSO, MUSIC/SP, ו־CICS.

בשנים 1973–1974, פטריק הַאגֶרְטִי ניהל את מימוש מפרש ה־APL של אוניברסיטת מרילנד עבור המחשבים המרכזיים מסדרת UNIVAC 1100/2200 של היצרנית Sperry. באותו הזמן למחשבי Sperry לא היה קיים מימוש APL.

בשנות ה־60 ושנות ה־70, מספר ספקיות של שיתוף משאבים מכרו שרותי APL ללקוחות שלהם בעזרת גרסאות שונות של המפרש APL\360 של IBM. באמריקה הצפונית, הספקיות הידועות היו I. P. Sharp Associates (IPSA), Scientific Time Sharing Corporation (STSC), Time Sharing Resources (TSR), ו־ The Computer Company (TCC). הספקית CompuServe הצטרפה מאוחר יותר לשוק ב־1978 עם מפרש APL שהיה מבוסס על זה של DEC ו־אוניברסיטת קרנגי מלון ורץ על KI ו־KL, מחשבי 36 סיביות של DEC. כשהחלו להופיע מחשבים מרכזיים זולים יותר כמו IBM 4300, ומאוחר יותר גם המחשבים האישיים באמצע שנות ה־80, כל תעשיית שיתוף המשאבים נעלמה כליל.

*Sharp APL* הייתה תוכנה של חברת I. P. Sharp Associates, שהתחילה כשירות שצמח מתעשיית שיתוף המשאבים במחשבים מרכזיים בשנות ה־60, ומאוחר יותר הפכה למוצר עצמאי החל משנת 1979. Sharp APL היה מימוש מתקדם יחסית של APL עם הרחבות כגון מערכת קבצים, מערכים מקוננים, ומשתנים משותפים.

מפרשי APL היו זמינים גם מיצרניות מחשבים אחרות: בורוז, קונטרול דאטה, דאטה ג'נרל, DEC, Harris, היולט פקארד (HP), Siemens AG, זירוקס ואחרות.

גַארְתְ' פוֹסְטֶר מאוניברסיטת סירקיוז יזם מפגשים קבועים עבור קהילת המממשים של APL במרכז הכנסים של סירקיוז, ב־Blue Mountain Lake שבמדינת ניו יורק. מאוחר יותר ארגן יוגִ'ין מַקְדוֹנֶל מפגשים דומים במרכז הכנסים אַסִילוֹמַאר ליד מונטריי, וב-Pajaro Dunes שליד ווטסונוויל בקליפורניה. קבוצת המשתמשים SIGAPL (ראשי תיבות: "***S'''pecial '''I'''nterest '''G'''roup on '''A'''rray '''P'''rogramming '''L'''anguages''") של [[ACM]] ממשיכה לתמוך בקהילת APL.

=== מיקרו־מחשבים ===
ה[[מיקרו-מחשב|מיקרו־מחשבים]] החלו להופיע ב[[שנות ה-70 של המאה ה-20|שנות ה־70]] והשפה הנפוצה בהם הייתה [[BASIC]]. עם זאת, מיקרו־מחשבים מסוימים הציעו את APL כתחליף - הראשון היה ה־[[MCM/70]], שהיה מבוסס על [[Intel 8008]] והושק ב־[[1974]], והשימוש המרכזי בו היה בתחום החינוך וההוראה. מיקרו־מחשב נוסף שהציע מפרש APL היה ה־[[VideoBrain Family Computer]] שהושק ב־[[1977]] עם תוכנת ''APL/S''.

ה־[[Commodore PET|Commodore SuperPET]] שהושק ב־[[1981]] כלל מפרש APL שפותח על ידי [[אוניברסיטת ווטרלו]].

בשנת [[1976]] טען [[ביל גייטס]] ב[[המכתב הפתוח לחובבי מחשבים|מכתבו הפתוח לחובבי מחשבים]], ש־[[מיקרוסופט|Microsoft]] עבדה על מימוש APL עבור [[Intel 8080]] ו־[[מוטורולה 6800]], אבל היה לה "מעט מאוד תמריץ להפוך אותו לזמין עבור חובבי מחשבים" לנוכח הפופולריות של [[פיראטיות תוכנה]] שמיקרוסופט חוותה עם מפרש ה-BASIC שלה. מפרש ה־APL של מיקרוסופט אכן מעולם לא הושק.

=== APL2 ===
מתחילת [[שנות ה-80 של המאה ה-20|שנות ה־80]] קבוצת הפיתוח של APL ב-IBM תחת הנהגתו של ג'ים בראון פיתחה גרסה חדשה של APL שהחידוש המרכזי בה היה קינון [[מערך (מבנה נתונים)|מערכים]], כלומר תיאור מערכים המכילים מערכים אחרים בתוכם, ומספר חידושים נלווים של השפה כדי לשלב בה את המערכים המקוננים. קנת' אייברסון, שכבר לא היה בשליטה על הפיתוח של APL, עזב את IBM והצטרף ל־[[I. P. Sharp Associates]] (IPSA), שם תרם רבות לפיתוחה של ''Sharp APL'' לפי השקפתו וחזונו. APL2 עדיין זמינה עבור מחשבים מרכזיים, והושקה לראשונה עבור מערכות [[Conversational Monitor System|CMS]] ו־[[Time Sharing Option|TSO]] בשנת [[1984]].

כשיצרניות אחרות התחילו לפתח [[מפרש (תוכנה)|מפרשי]] APL עבור [[חומרה]] חדשה, במיוחד עבור [[מיקרו-מחשב|מיקרו־מחשבים]] מבוססי [[Unix|יוניקס]], APL2 הייתה לרוב הבחירה הסטנדרטית. אפילו כיום, מפתחי APL מצהירים על תאימות עם APL2 בשיווק המוצרים שלהם. IBM ציטטה את השימוש בה עבור [[פתרון בעיות]], עיצוב מערכות, פיתוח אבות טיפוס, חישובים הנדסיים ומדעיים, [[מערכת מומחה|מערכות מומחות]], לימוד מתמטיקה ונושאים אחרים, הדמיה, וגישה ל[[בסיס נתונים|מסדי נתונים]]. מהדורת ה־''Workstation'' של APL2 עבור המערכות [[Microsoft Windows|Windows]], [[OS/2]], [[IBM AIX|AIX]], [[לינוקס|Linux]], ו־[[Solaris]] הושקה רק ב[[שנות ה-90 של המאה ה-20|שנות ה־90]].

בשנת 2021 מכרה IBM את APL2 לחברת Log-On Software, אשר מפתחת ומוכרת אותה בשם Log-On APL2.

=== מימושים מודרניים ===
מימושי APL של APLX, Dyalog ואחרים כוללים הרחבות לשפה כמו תמיכה ב[[תכנות מונחה-עצמים]], תמיכה ב־[[.NET Framwork]], טיפול בקובצי [[XML]], [[תרשים|הדפסת תרשימים]], ממשקים למערכת ההפעלה, וביטויי [[תחשיב למדא]].

=== שפות תכנות נגזרות ===
APL היא הבסיס או השפיעה באופן ניכר על [[שפת תכנות]] אחרות:
* [[A+ (שפת תכנות)|A ו־A+]] - אלטרנטיבה ל־APL, השנייה מציעה הרחבות גרפיות.
* [[FP (שפת תכנות)|FP]] - שפת ל[[תכנות פונקציונלי]].
* [[J (שפת תכנות)|J]] - שפה נוספת שעוצבה על ידי אייברסון. ומשתמשת בתווי [[ASCII]] ומילות מפתח במקום הסימון המתמטי המקורי של APL.
* [[K (שפת תכנות)|K]] - גרסה קניינית של APL שפותחה על ידי ארתור וִיטְנִי.
* [[LYaPAS]] - ניב APL בשפה ה[[רוסית]] שפותח בברית המועצות.
* [[MATLAB]] - כלי ל[[אנליזה נומרית|חישובים נומריים]].
* [[Nial (שפת תכנות)|Nial]] - שפת [[תכנות מערכים]] עילית עם סימון האופייני ל[[תכנות פונקציונלי]].
* [[PPL (שפת תכנות)|PPL]] - (ראשי תיבות ***P**olymorphic **P**rogramming **L**anguage'') שפת תכנות שפותחה ב[[אוניברסיטת הרווארד]].
* [[S (שפת תכנות)|S]] - שפת תכנות לחישובים [[סטטיסטיקה|סטטיסטיים]] (מוכרת בגרסת הקוד הפתוח שלה, [[R (שפת תכנות)|R]]).
* [[Speakeasy (שפת תכנות)|Speakeasy]] - סביבה אינטראקטיבית ל[[אנליזה נומרית|חישובים נומריים]].
* [[Wolfram Language]] - שפת התכנות של [[Mathematica]], מערכת ל[[מתמטיקה חישובית]].

== תכונות השפה ==
=== מערכת תווים ===
מערכת [[תו (מחשב)|התווים]] הייחודית והלא מוכרת של APL הייתה עבורה מקור לביקורת ושבח כאחד. התופעה ש[[מתכנת]]ים שלומדים ומסתגלים אליה הופכים לחסידים נלהבים שלה יכולה לרמוז שאכן קיים משקל מהותי לסימון המתמטי המקורי של אייברסון וזהו חלק בלתי נפרד מהשפה. ב[[שנות ה-60 של המאה ה-20|שנות ה־60]] ו[[שנות ה-70 של המאה ה-20|ה־70]] מעט [[מסוף מחשב|מסופים]] יכלו להציג את הסימנים של APL. הפופולריים ביניהם ניצלו את התמיכה של מכונת הכתיבה IBM Selectric בעזרת החלפת ראש ההדפסה. המסוף הראשון שידע להציג את כל התווים של APL היה מסוף החד־שורה [[TI Model 745]] של [[Texas Instruments]] שהושק ב־[[1977]].

עם הופעת ה[[צג|צגים הגרפיים]], ה[[מדפסת|מדפסות]], ו[[קידוד תווים|קידוד]] ה־[[Unicode]], בעיית התווים של APL כמעט נעלמה. עם זאת, כתיבת APL עדיין דורשת [[עורך טקסט|עורכי טקסט]] שתומכים ב[[שיטת קלט]] ייחודית לה, מיפוי מקלדות, לעיתים שימוש ב[[מקלדת וירטואלית]], או הדבקת תווים מודפסים על גבי המקלדת, פתרונות מתסכלים עבור מתכנתים עם רקע משפות תכנות אחרות. אצל מתחילים שאין להם רקע קודם בתכנות, מחקר שנוסה על תלמידי תיכון הראה שכתיבת תווי APL לא הפריעה לתלמידים לתכנת באופן ניכר.

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

=== עיצוב ===
בניגוד לשאר השפות [[תכנות מובנה|המובנות]], קוד טיפוסי של APL בדרך כלל בנוי כשירשור של אופרטורים, [[שגרה (תכנות)|פונקציות]] ''[[פעולה אונארית|מונאדיות]]'' ו''[[פעולה בינארית|דיאדיות]]'' (המונחים של APL עבור פעולות אונאריות ובינאריות) על/בין [[מערך (מבנה נתונים)|מערכים]]. ל־APL קיימים פרימיטיבים (המונח של APL לפונקציות ופעולות המובנות בשפה) רבים המתוארים על ידי סימן בודד או הרכבה של מספר סימנים. לכל הפרימיטיבים ב־APL יש [[קדימות אופרטורים|קדימות]] שווה, והם אסוציאטיביים עם קדימות לימין. כתוצאה מכך, הבנת הקוד ב־APL נוחה יותר בקריאה מימין לשמאל.

מימושים מוקדמים של APL (בסביבות [[שנות ה-70 של המאה ה-20|שנות ה־70]]) לא כללו [[בקרת זרימה]], כגון <code dir="ltr">do</code>, <code dir="ltr">while</code> או מבני קוד מהצורה <code dir="ltr">if-then-else</code>. APL עודדה הפעלת [[שגרה (תכנות)|פונקציות]] על פני [[מערך (מבנה נתונים)|מערכים]] שלמים, דבר שפטר את המתכנת מהצורך לכתוב [[תכנות מובנה|קוד מובנה]] עם בקרת זרימה מפורשת. לדוגמה הפונקציה <code dir="ltr">iota</code> (בסימונו של אייברסון: <code dir="ltr">ι</code>) יכלה להחליף [[איטרציה]] של לולאת <code dir="ltr">for</code>: <code dir="ltr">ιN</code> כאשר N הוא [[סקלר (מחשבים)|סקלר]] חיובי ושלם תחזיר מערך חד־ממדי מהצורה <math>[1, 2, 3 ... N]</math>. מימושי APL חדשים יותר כוללים בקרת זרימה ומבני קוד מקיפים המאפשרים הפרדה ברורה בין בקרת הזרימה של התהליכים ל[[מבנה נתונים|מבני הנתונים]].

סביבת התכנות של APL נקראת ''workspace'' (עברית: ''סביבת עבודה''). בסביבת עבודה משתמש יכול להגדיר [[משתנה (תכנות)|משתנים]] עבור נתונים ו[[שגרה (תכנות)|שגרות]] עבור [[תהליך (מדעי המחשב)|תהליכים]] ב־APL. המשתמש יכול לבצע פעולות על המשתנים תוך שימוש ב[[מפרש (תוכנה)|מפרש]] כמו ב[[שפת תסריט]]. בדוגמאות למטה, המפרש מזין 6 רווחים בתחילת השורה לפני קבלת ה[[קלט]] מהמשתמש, ומדפיס [[פלט]] בהתאם.



המשתמש יכול לשמור את סביבת העבודה יחד עם כל המשתנים וה[[שגרה (תכנות)|שגרות]] שהגדיר בה, ולהקפיא את מצב הריצה הנוכחי שלה.

APL משתמשת בסימנים שאינם כלולים ב־[[ASCII]]. הסימנים גם מרחיבים את הסימון המקובל ב[[אלגברה]] וב[[ארבע פעולות החשבון|פעולות חשבון]] בסיסיות. היכולת לבטא פעולות המטפלות בריבוי נתונים ([[SIMD]]) על גבי מערכים בעזרת [[תו (מחשב)|תו]] ייחודי בודד מאפשרת לנסח [[אלגוריתם|אלגוריתמים]] כמו [[משחק החיים (אוטומט תאי)|משחק החיים]] בשורה אחת בלבד. תאורטית, ברוב הגרסאות של APL, ניתן לבטא כל פונקציה בעזרת ביטוי בודד, כלומר בשורה אחת.

כדי לכתוב את הסימנים המיוחדים של APL, מתכנתים נוהגים להשתמש במקלדות ייעודיות עם מקשים שעליהם מוצגים הסימנים. אף על פי שיש מספר דרכים לכתוב קוד ב־APL בעזרת תווי ASCII, אין זה מקובל בפועל (עובדה זו יכולה לתמוך בתזה של אייברסון - "''סימון ככלי חשיבה''"). רוב המימושים המודרניים משתמשים בפריסה הסטנדרטית של המקלדות, עם [[שיטת קלט]] הממפה את המקשים לתווים הייחודיים של APL. היסטורית, ה[[גופן]] של APL התאפיין באותיות אלפביתיות גדולות ב[[כתב נטוי]], וכתב ישר עבור המספרים והסימנים. רוב המימושים עדיין מספקים גופנים ייעודיים כדי להציג קוד APL.

חסידי השפה מתמודדים עם הטענה שהסימון של APL הפך אותה לשפת ''כתיבה בלבד'' (באנגלית: ''write-only language'', ביטוי לעגני לשפת תכנות לא מובנת, שקשה לקרוא ולהבין [[קוד מקור]] שנכתב בהן. הביטוי נגזר מניגוד של המונח ''קבצים לקריאה בלבד'' המוגנים מכתיבה במערכת), בכך שקוד בלתי קריא הוא ברוב המקרים תוצאה של חוסר מיומנות של המתכנת, או טעויות של מתכנתים מתחילים שאינם בקיאים באופן הכתיבה המקובל והאופייני לשפה, דבר שיכול לקרות בכל שפה. יתר על כך, נטען כי APL מאפשרת לכתוב קוד הרבה יותר מתומצת שדורש פחות זמן גם בכתיבה וגם בעיון, ובסופו של דבר חוסך בזמן ובמתכנתים.

טיעון נוסף הוא כי מאחר שהשפה היא מאוד תמציתית, היא מתאימה יותר לפיתוח תוכנות בקנה מידה גדול, כיוון שהיא מאפשרת הקטנה ניכרת של מספר שורות הקוד. מתכנתי APL רואים שפות אחרות כגון [[Java]] ו־[[COBOL]] כמסורבלות וטרחניות. APL אכן נפוצה במקומות שבהם לזמן הפיתוח יש חשיבות קריטית מהיבט עסקי, כמו ב[[מסחר אלגוריתמי|מערכות מסחר אלגוריתמיות]] ו[[מסחר אוטומטי|אוטומטיות]].

=== מינוח ===
APL עושה הבדלה ברורה בין [[שגרה (תכנות)|פונקציות]] (שגרות) ו[[אופרטור (תכנות)|אופרטורים]] (פעולות). פונקציות מקבלות מערכים (מתוך משתנים, קבועים, או ביטויים) כפרמטרים, בזמן שאופרטורים (בדומה ל[[תכנות פונקציונלי|שפות פונקציונליות]]) יכולים לקבל כפרמטרים גם פונקציות וגם מערכים ולהחזיר פונקציה חדשה משילוב של פונקציות ופעולות קיימות. לדוגמה פונקציית סיכום מערכים ב־APL נוצרת מהחלת פונקציית החיבור (<code dir="ltr">+</code>) בעזרת אופרטור הצמצום (ב־APL מילולית: ''reduction'' או בסימון המתמטי של אייברסון <code dir="ltr">/</code>) על מערך. אופרטור הצמצום מפעיל את הגורם משמאל, במקרה זה: פונקציית החיבור, בין כל שני פריטים בתוך המערך שנמצא מימין, ובכך מביא לחיבור של כל הפריטים בתוכו ומחזיר את סכומם. כדוגמה נוספת, הפעלת פונקציית המקסימום (<code dir="ltr">⌈</code>, המחזירה את הערך הגדול מהשניים) בעזרת פעולת הצמצום (<code dir="ltr">/</code>) על גבי מערך תפעיל את הפונקציה בין כל שני פריטים בתוכו ובכך תחזיר את הערך הגדול מכל הפריטים בו. מאוחר יותר בשפת J, אייברסון שינה את המינוח ל־''פוֹעַל'' (באנגלית: ''verb'') עבור פונקציות; ול־''תואר פועל'' או ל־''מילת חיבור'' (באנגלית: ''adverb'' או ''conjunction'') עבור אופרטורים.

חלוקה זאת היא חלק בלתי נפרד מהשפה עצמה, ורוב הפרימיטיבים שלה גם מתחלקים לשתי הקטגוריות האלה, למעט מספר מועט של חריגים שאינם פונקציות ואינם אופרטורים, כגון פעולת ההשמה (<code dir="ltr">←</code>). כתיבת קוד חדש ב־APL היא לרוב פיתוח פונקציות חדשות, ורק לעיתים רחוקות אופרטורים חדשים.

מונחים מסוימים ב־APL לעיתים אינם תואמים את השימוש הנהוג בהם בספרות הקשורה ל[[מתמטיקה]] ובכלל ב[[מדעי המחשב]].



=== תחביר ===


=== דוגמאות ===
==== "Hello World" ====
הדפסת השורה "Hello World" ב־APL תעשה כך:
<syntaxhighlight lang="apl">
'Hello, world!'
</syntaxhighlight>
ב־APL מקובל להגדיר פעולות [[ברירת מחדל]] במקרים שבהם לא מצוינת אף פעולה או פונקציה אחרת. ה[[מחרוזת (מדעי המחשב)|מחרוזת]] <code dir="ltr">'Hello, world!'</code> מודפסת כ[[פלט]] מכיוון שפעולת ברירת המחדל ב־APL היא הדפסת פלט.

==== העלאה בחזקה ====
העלאה בחזקה ב־APL נעשית בעזרת הפונקציה <code dir="ltr">⋆</code> כך: <code dir="ltr">2⋆3</code>, כלומר 2 בחזקת 3 (זה יכתב כ־<code dir="ltr">2^3</code> במספר שפות אחרות, וכ־<code dir="ltr">2**3</code> בשפות כמו [[פייתון]] ו־[[Fortran]]). עם זאת, במקרה שלא צוין בסיס (כגון <code dir="ltr">⋆3</code>), APL תניח שהבסיס הוא הקבוע [[E (קבוע מתמטי)|e]] (...2.71828), ולכן <code dir="ltr">⋆3</code> יהיה שקול ל־<code dir="ltr">2.71828⋆3</code>.

==== סטטיסטיקה פשוטה ====
נניח ש־<code dir="ltr">X</code> הוא מערך מספרים, אז הביטוי <code dir="ltr">(+/X)÷⍴X</code> מחזיר את ה[[ממוצע חשבוני|ממוצע החשבוני]] שלהם. בקריאה מימין לשמאל (כפי שהקדימות ב־APL עובדת), <code dir="ltr">⍴X</code> נותן את מספר הפריטים במערך X, ומאחר ש־<code dir="ltr">÷</code> היא פעולה דיאדית ([[פעולה בינארית|בינארית]]), הערכה מלאה של הביטוי משמאל דרושה לפני הפעלתה. הביטוי משמאל מוקף בסוגריים כי אחרת X לבדו יילקח כפרמטר לפני פעולת הסיכום <code dir="ltr">+/X</code> המחברת כל הפריטים בתוך X. בהתבסס על זה, הביטוי <code dir="ltr">((+/((X - (+/X)÷⍴X)*2))÷⍴X)*0.5</code> מחשב את [[סטיית תקן|סטיית התקן]]. יתר על כן, מאחר שהשמה למשתנה (<code dir="ltr">←</code>) נחשבת לפעולה, ניתן להשתמש בה בתוך הקוד גם כן ולקבל:
<syntaxhighlight lang="apl">
SD←((+/((X - AV←(T←+/X)÷⍴X)*2))÷⍴X)*0.5
</syntaxhighlight>
דבר שיאפשר שימוש חוזר במשתנים <code dir="ltr">SD</code>, <code dir="ltr">AV</code>, ו־<code dir="ltr">T</code>. באופן שגרתי, מתכנת APL יגדיר את הביטוי כפונקציה במקום לכתוב אותו כל פעם מחדש.

==== בחירת 6 מספרים להגרלה ====
הביטוי הבא מציג דוגמה לבחירת 6 מספרים שלמים פסודו־[[אקראיות|אקראיים]] להגרלה הנעים בין 1 ל־40, שאינם חוזרים על עצמם, ומדפיס אותם בסדר עולה.
<syntaxhighlight lang="apl">
x[⍋x←6?40]
</syntaxhighlight>
הקוד התמציתי לעיל משלב את הפונקציות הבאות:
* הראשונה שתעבור הערכה (מאחר ש־APL מעריכה ביטויים בקדימות מימין לשמאל) תהיה הפונקציה הדיאדית <code dir="ltr">?</code> (מכונה באנגלית ''deal'' כשנעשה בה שימוש דיאדי), שתחזיר מערך שגודלו לפי הפרמטר משמאל (במקרה זה: 6) ובו מספר/ים בטווח לפי הפרמטר מימין מימין (במקרה זה: 40), כלומר היא תחזיר מערך בגודל 6 פריטים שערכם מוגרל בין 1 ל-40 באופן אקראי.
* פעולת ההשמה <code dir="ltr">←</code> תקלוט את המערך שהחזירה <code dir="ltr">?</code> לתוך המשתנה <code dir="ltr">x</code>.
* המערך יעבור [[מיון (אלגוריתם)|מיון]] מחדש בסדר עולה על ידי הפונקציה המונאדית <code dir="ltr">⍋</code> שתיקח את כל מה שתחום בסוגריים המרובעים (המתייחסים בפועל לאינדקס המערך <code dir="ltr">x</code>) כפרמטר לימינה.
* הסוגריים המרובעים יקלטו את הסידור החדש מ־<code dir="ltr">⍋</code> עבור המערך <code dir="ltr">x</code>.

מאחר שלא צוינה אף פונקציה משמאל ל־<code dir="ltr">x</code> שתנחה מה לעשות עם הפלט, המפרש פשוט ידפיס אותו בשורה אחת כשכל פריט במערך מופרד ברווח בלי הנחיה נוספת.

הפונקציה <code dir="ltr">?</code> יכולה גם להיות מונאדית (כלומר אונארית, במקרה זה היא מכונה "''roll''" באנגלית), ואז היא תחזיר מספר אקראי בודד לפי טווח הפרמטר שמשמאל. לדוגמה <code dir="ltr">?20</code> תחזיר מספר אקראי בין 1 ל־20.

==== מספרים ראשוניים ====
הביטוי הבא יחשב את כל [[מספר ראשוני|המספרים הראשוניים]] מ־1 עד R. [[סיבוכיות]] החישוב תהיה <math>O(R^2)</math> גם ב[[סיבוכיות זמן|זמן הריצה]] וגם בצריכת ה[[זיכרון מחשב|זיכרון]].
<syntaxhighlight lang="apl">
(~R∊R∘.×R)/R←1↓ιR
</syntaxhighlight>
הביטוי מפורש מימין לשמאל כך:
* הפונקציה <code dir="ltr">ι</code> (''יוטא'') יוצרת מערך חדש של מספרים שלמים מ־<code dir="ltr">1</code> עד <code dir="ltr">R</code> בסדר עולה. (כך שאם <code dir="ltr">R=6</code> בתחילת הריצה אז <code dir="ltr">ιR</code> יחזיר את המערך <math>[1,2,3,4,5,6]</math>.
* השמט את הפריט הראשון מהמערך שנוצר (כלומר את <code dir="ltr">1</code>) בעזרת הפונקציה <code dir="ltr">↓</code>, כך שבהמשך הדוגמה לעיל <code dir="ltr">1↓ιR</code> יחזיר את המערך <math>[2,3,4,5,6]</math>.
* הגדר את המשתנה <code dir="ltr">R</code> להיות המערך החדש שהתקבל מ־<code dir="ltr">↓</code> בעזרת פעולה הייחוס <code dir="ltr">←</code>.
* פעולת הצמצום <code dir="ltr">/</code> תכריח את אגף שמאל (המוקף בסוגריים) לעבור הערכה מלאה קודם כל לפני החלתו בין כל שני פריטים במערך שהתקבל עד כה באגף ימין.
* צור [[מטריצה]] דו־ממדית המתארת את תוצאות מכפלת כל הפריטים במערך <code dir="ltr">R</code> אופקית ואנכית על ידי הפעולה <code dir="ltr">°.×</code> (הנמצאת בין <code dir="ltr">R</code> ו־<code dir="ltr">R</code>). התוצאה שתתקבל תהיה:

<math>\begin{bmatrix}
4 & 6 & 8 & 10 & 12 \\
6 & 9 & 12 & 15 & 18 \\
8 & 12 & 16 & 20 & 24 \\
10 & 15 & 20 & 25 & 30 \\
12 & 18 & 24 & 30 & 36 \\
\end{bmatrix}</math>
* בעזרת פעולת <code dir="ltr">∈</code> (מכונה ''פעולת אפסילון'' או ''בדיקת שייכות''), בנה מערך חדש באותו האורך של <code dir="ltr">R</code>, כשכל פריט במערך יהיה <code dir="ltr">1</code> אם הפריט באותו מיקום במערך <code dir="ltr">R</code> המקורי נמצא בתוך הטבלה שהתקבלה לעיל, אחרת הפריט יהיה <code dir="ltr">0</code>. למעשה הפעולה <code dir="ltr">∈</code> מחזירה משוב על איזה פריטים במערך משמאל כלולים במבנה מימין. התוצאה תהיה <math>[0,0,1,0,1]</math> כי רק <code dir="ltr">4</code> ו־<code dir="ltr">6</code> הופיעו בטבלה.
* [[לא (לוגיקה)|שלול]] [[לוגיקה בוליאנית|לוגית]] את כל הערכים במערך שהתקבל מ־<code dir="ltr">∈</code> בעזרת הפעולה <code dir="ltr">∼</code> המייצגת שלילה לוגית ב־APL. התוצאה עד כה תהיה <math>[1,1,0,1,0]</math>.
* חזור והשלם את פעולת הצמצום <code dir="ltr">/</code> אחרי ששני האגפים עברו הערכה מלאה. במקרה זה, כשיש מערך בוליאני מימין ומערך כלשהו משמאל, פעולת הצמצום תחזיר מערך חדש ובו מסוננים רק הפריטים מהמערך מימין (<code dir="ltr">R</code>) עבורם הופיע ערך חיובי (<code dir="ltr">1</code>) במערך משמאל (התוצאה של <code dir="ltr">∼</code>). התוצאה הסופית תהיה <math>[2,3,5]</math>, שלושת המספרים הראשוניים בטווח כש־<code dir="ltr">R=6</code>.

==== מיון ====
הדוגמה הבאה [[מיון (אלגוריתם)|תמיין]] מערך מחרוזות בסדר עולה לפי מספר התווים בכל מחרוזת.
<syntaxhighlight lang="apl">
X[⍋X+.≠' ';]
</syntaxhighlight>

==== משחק החיים ====
הפונקציה הבאה (<code dir="ltr">life</code>), כתובה ב־Dyalog APL, לוקחת [[מטריצה]] בוליאנית ומחשבת את הצעד הבא לפי האלגוריתם של [[משחק החיים (אוטומט תאי)|משחק החיים]]. הדוגמה הזאת מפגינה את היכולת של APL לבטא תהליכים מורכבים במעט קוד. עם זאת היא קשה להבנה ללא ידע מתקדם ב־APL.
<syntaxhighlight lang="apl">
life←{↑1 ⍵∨.∧3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵}
</syntaxhighlight>

==== הסרת תגיות HTML ====
הדוגמה הבאה, גם כתובה ב־Dyalog APL, מראה קליטת טקסט [[HTML]] אקראי לתוך המשתנה <code dir="ltr">txt</code> ואז משתמשת בביטוי הכתוב ב־APL על מנת להפשיט את הקלט מכל [[תגית HTML|תגיות ה־HTML]] שמעורבים בו ואז מדפיסה פלט ללא התגיות.
<syntaxhighlight lang="apl">
 txt←'<html><body><p>This is <em>emphasized</em> text.</p></body></html>'
 {⍵ /⍨ ~{⍵∨≠\⍵}⍵∊'<>'} txt
This is emphasized text.
</syntaxhighlight>

== שימושיות ==
APL משמשת כ[[שפת תכנות|שפה תכנות]] כללית ורב תחומית ונעשה בה שימוש מסחרי ומדעי נרחב בעבר, בין היתר ל[[יישום מחשב|יישומים]] בתחום ה[[מימון|פיננסי]], [[ניהול השקעות]], [[ביטוח]], [[בינה מלאכותית]], [[למידת מכונה]], [[רובוטיקה]], [[ניהול נכסים]], [[שרותי בריאות]], [[זיהוי DNA]], ועל ידי חובבי תכנות. יש הטוענים כי APL אינה [[שפת תכנות]] אלא כלי חישוב מאחר שהאופי [[מתמטיקה חישובית|הסימבולי]] ויכולת הטיפול שלה ב[[מערך (מבנה נתונים)|מערכים]] עיצבו אותה ואת אופן השימוש שלה מן היסוד ולכן היא הפכה לכלי ייעודי עבור [[מדען נתונים|מדעני נתונים]] ו[[מחקר|אנשי מחקר]] המתמחים בתחומים ממוקדים ואינם נדרשים בהכרח לכישורים של [[הנדסת תוכנה]].

APL מתאימה מאוד ל[[עיבוד תמונה מגמתי|עיבוד תמונות מגמתי]] ו[[הנפשה ממוחשבת]] שבהם טרנספורמציות גרפיות יכולות להיות ממומשות כמכפלת [[מטריצה|מטריצות]]. אחד מאולפני ה[[גרפיקה ממוחשבת|גרפיקה הממוחשבת]] המסחריים הראשונים בארצות הברית, [[Digital Effects (אולפן)|Digital Effects]], פיתחו ב־APL את ''Visions'', ויצרו בעזרתה את פרסומות הטלוויזיה והאנימציות לסרט [[טרון (סרט)|Tron (1982)]]. מאוחר יותר, [[סימולציות ניהול ממוחשבות|סימולטור השייט]] ''Stormwind'' מיישם את כל רכיבי הליבה שלו, את מנוע ה[[גרפיקת תלת-ממד|הדמיה התלת־ממדית]], ואת רוב סימולציית הפיזיקה שלו בעזרת APL.

== מימושים בולטים ==
=== APL\360 ===
המימוש הראשון של APL שהתאפיין במערכת הסימנים של אייברסון היה ''APL\360'' שרץ על מחשבי [[IBM System/360]], והושלם בנובמבר [[1966]] אף על פי שבאותו הזמן השימוש בו היה פנימי בלבד בתוך [[IBM]]. בשנת [[1973]] היוצרים שלו, לַארי בְּרִיד, דִיק לַאתְ'װֶל, ורוֹגֶ'ר מוּר זכו ב[[פרס גרייס מאריי הופר]] של ה-[[ACM]] על "עבודתם בתכנון ומימוש APL\360, קביעת סטנדרטים חדשים בפשטות, יעילות, אמינות, וזמן תגובה למערכות אינטראקטיביות.".

ב־[[1975]], [[מיקרו-מחשב|מיקרו־מחשבים]] מסוג [[IBM 5100]] הציעו את APL\360 כאחת משתי השפות המובנות בזיכרון ה־[[זיכרון לקריאה בלבד|ROM]] שלהם, יחד עם מקלדת וצג שתמכו בכל סימני APL.

פיתוחים משמעותיים ב־APL\360 היו ''CMS/APL'', שהשתמשה ב[[זיכרון וירטואלי|זיכרון הווירטואלי]] של מערכת ה־[[Conversational Monitor System|CMS]]; ו־''APL.SV'' אשר הציגה לראשונה את ''המשתנים המשותפים'', משתנים ופונקציות לתיווך בין APL ומערכת ההפעלה. מאוחר יותר APL\360 עברה התאמה עבור מחשבי ה־[[IBM System/370]] ו־[[VSPC]]. פיתוחה המשיך עד גרסתה האחרונה שהושקה ב־[[1983]], ולאחר מכן היא הוחלפה ב־APL2.

=== APL\1130 ===
בשנת [[1968]] הושק ''APL\1130'', מימוש ה־APL הראשון שהיה זמין לציבור הרחב מחוץ למעבדות של IBM. המימוש פותח על ידי IBM עבור מחשבי ה־[[IBM 1130]]. היא הפכה לתוכנת ה־[[IBM Type-III Library]] הפופולרית ביותר ש־IBM השיקה אי פעם.

=== APL*Plus ו־Sharp APL ===
''APL*Plus'' ו־''Sharp APL'' הן גרסאות של APL\360 עם הרחבות שהיו חיוניות עבור חברות מסחריות באותו הזמן. ההרחבות כללו עיצוב תבניות עבור נתונים, ואמצעים לשמירת מערכי APL בקבצים חיצוניים. שני המימושים פותחו בשתי חברות נפרדות שהעסיקו עובדים מהצוות המקורי ב־IBM שפיתח את APL\360.

שתי החברות היו [[I. P. Sharp Associates]] (IPSA), חברת שירותי APL\360 שנוסדה ב־[[1964]] על ידי אִיאַן שַארְפּ, רוֹגֶ'ר מוּר ואחרים, והשנייה הייתה [[Scientific Time Sharing Corporation]] (STSC) חברה לשירותי שיתוף משאבים ושירותי ייעוץ שנוסדה ב־[[1969]] על ידי לורנס בְּרִיד ואחרים. שתי החברות פיתחו יחד את APL*Plus, הן המשיכו לעבוד יחד אף על פי שבהמשך הזמן הפיתוח שלהן התפצל לשני מימושים נפרדים: Sharp APL ו־APL*Plus.

STSC ייצאה את APL*Plus להרבה [[פלטפורמת מחשוב|פלטפורמות]], ביניהן [[VAX]] 11, [[מחשב אישי|מחשבים אישיים]], ו־[[Unix]], ואילו IPSA בחרה להפוך את המימוש שלה (Sharp APL) זמין למחשבים אישיים בעזרת ''PC-XT/360'', רכיב חומרה שסיפק שכבת תאימות למחשבים אישיים עבור תוכנות שפותחו במקור ל[[מחשב מרכזי|מחשבים מרכזיים]] של IBM.

ב־[[1993]], נוסדה החברה [[קנדה|הקנדית]] [[Soliton Incorporated]] כדי לתמוך ב־Sharp APL והמשך פיתוחה. היא פיתחה את ''SAX'' (ראשי תיבות Sharp APL ל־Unix). נכון ל־[[2018]], ''APL+Win'' הוא המימוש ההמשכי ל־APL*Plus.

ב־[[1985]], זכה איאן שארפ ב[[פרס אייברסון]] מטעם קבוצת SIGPAL ב־[[ACM]] על עבודתו ותרומתו לשפת APL.

=== APL2 ===
''APL2'' היה מימוש מחודש של APL\360 מאת IBM שהפיתוח שלו החל ב־[[1971]] והושק לראשונה ב־[[1984]]. APL2 הציגה שיפורים חשובים לשפה והבולט בהם היה קינון [[מערך (מבנה נתונים)|מערכים]] (הכלת מערכים בתוך מערכים). נכון ל־[[2018]], APL2 זמינה עבור [[מחשב מרכזי|מחשבים מרכזיים]] שרצים על [[z/OS]] או [[z/VM]], או תחנות עבודה שרצות על [[AIX]], [[Linux]], [[Solaris]] ו[[חלונות]].

כל הצוות שהיה אחראי על הפיתוח והתחזוקה של APL2 זכה ב[[פרס אייברסון]] משותף בשנת [[2007]].

=== Dyalog APL ===
המימוש ''Dyalog APL'' הושק לראשונה מאת Dyalog Ltd ה[[בריטניה|בריטית]] ב־[[1983]]. נכון ל־[[2018]] הוא זמין ל־[[Linux]] (כולל על ה־[[Raspberry Pi]]),[[AIX]], [[macOS]], ו[[חלונות]]. הוא מבוסס על APL2, ומציע הרחבות ל־APL בשביל [[תכנות מונחה עצמים]] ו[[תכנות פונקציונלי]]. הרישיון שלו הוא חינמי עבור שימוש פרטי ולא מסחרי.

ב־[[1995]], שניים מחברי צוות הפיתוח של Dyalog APL - ג'ון סקוֹלְס ו־פיטר דוֹנֶלי - זכו ב[[פרס אייברסון]] עבור עבודתם על ה[[מפרש (תוכנה)|מפרש]].

=== NARS2000 ===
''NARS2000'' (ראשי תיבות "**N**ested **A**rrays **R**esearch **S*'ystem") הוא [[מפרש (תוכנה)|מפרש]] APL [[תוכנה חופשית|חופשי]] ו[[קוד פתוח]] מאת בּוֹבּ סְמִית', מפתח וותיק מהצוות של STSC שעבדו על המימוש של APL*Plus ב[[שנות ה-70 של המאה ה-20|שנות ה־70]] ו[[שנות ה-80 של המאה ה-20|ה־80]]. NARS2000 כולל [[טיפוס נתונים|טיפוסי נתונים]] חדשים עבור השפה וחידושים אחרים.

=== APLX ===
*APLX* הוא ניב [[חוצה-פלטפורמות]] של APL, מבוסס על APL2 עם מספר הרחבות כמו תכנות מונחה עצמים ותמיכה ב־[[NET Framework.]]. הוא הושק לראשונה על ידי MicroAPL הבריטית ב־[[2002]]. APLX אינו נמצא יותר בשימוש מסחרי והפיתוח שלו הפסיק. ניתן להשיג אותו בחינם מהאתר של Dyalog.

=== GNU APL ===
*GNU APL* הוא מימוש [[תוכנה חופשית|חופשי]] מטעם המיזם של [[GNU]] עבור APL המורחבת כפי שאופיינה ב־*ISO/IEC 13751:2001*, ולכן הוא דומה ל־APL2. המימוש רץ על <span dir="ltr">GNU\[[Linux]]</span> ועל [[חלונות]] בעזרת [[Cygwin]] ומשתמש ב־[[Unicode]]. הוא פותח על ידי יורגן זאוארמן.

[[ריצ'רד סטולמן]], מייסד מיזם [[GNU]], היה מהראשונים שאימצו את APL. סטולמן נעזר ב־APL כדי לכתוב עורך טקסט כשהיה בתיכון בקיץ [[1969]].

== הידור ופירוש ==
APL היא [[שפה מפורשת]] בהתאם למסורת שלה, תכונותיה כגון [[מערכת טיפוסים#טיפוסיות דינמית|טיפוסיות דינמית]] הופכים אותה לשפה שאינה מתאימה ל[[הידור]] למרות זאת, מהיותה שפת [[תכנות מערכים]] המציבה את ה[[מערך (מבנה נתונים)|מערך]] במרכז השימוש בה, היא נותנת הזדמנות ל[[מיטוב אלגוריתמים|מיטוב]] תהליך ה[[מפרש (תוכנה)|פרוש]] שלה בעזרת [[עיבוד מקבילי]] של כל המערכים ובעזרת [[VLSI]]. מיטובים אלה הפכו את APL לשפת ביצועים גבוהים,לדוגמה APL מצטיינת בביצועיה בפעולות מורכבות עם מטריצות מאחר שהיא פועלת על גבי מערכים בלי [[בקרת זרימה]] ופעולות ביניים שמאטות שפות אחרות.

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

=== זיהוי צרופים ===
רוב מפרשי APL תומכים בזיהוי צרופים (באנגלית: *idioms*) הטיפוסיים לשפהומעריכים צרופים כאלה כפעולה אחת וחוסכים את צעדי הביניים.לדוגמה, כשהמפרש מזהה צרוף מהצורה <code>BV/⍳⍴A</code> (היכן ש־<code>BV</code> הוא ערך בוליאני ו־<code>A</code> הוא מערך), הוא מיד מעריך את כל הביטוי כפעולה אחת במקום לפרש את הביטוי צעד אחר צעד, ובכך הוא בעצם חוסך את יצירתם של שני מערכים נוספים בפעולות הביניים על מנת להשלים את הביטוי.

=== בייטקוד ממוטב ===
ה[[מערכת טיפוסים#טיפוסיות דינמית|טיפוסיות הדינמית]] של APL מאפשרת ל[[משתנה (תכנות)|משתנים]] להצביע על [[מערך (מבנה נתונים)|מערכים]] (מכל [[טיפוס נתונים|טיפוס]]), [[שגרה (תכנות)|פונקציות]], או [[אופרטור (תכנות)|פעולות]] (אופרטורים). באופן הכללי המפרש לא יכול לדעת באיזה טיפוס מדובר בלי לבצע ניתוח תחבירי ובדיקת טיפוסיות בזמן ריצה.עם זאת, במקרים מסוימים ניתן להסיק באיזה טיפוסיות (יהיה) מדובר עוד לפני הריצה ולהכין [[Bytecode|בייטקוד]] [[מיטוב אלגוריתמים|ממוטב]] מראש שייעל את הביצועים. את הבייטקוד ניתן למטב בעזרת שיטות מיטוב ידועות כגון זיהוי והידור מראש של ביטויים קבועים שאינם משנים את ערכם לאורך כל זמן הריצה (באנגלית: *Constant folding*), והחלפת והשמטת ביטויים השקולים זה לה במשתנה המצביע לביטוי המשותף לכל המקרים (באנגלית: *Common subexpression elimination*).בזמן הריצה המפרש יריץ את מקטע הבייטקוד שהוכן מראש אך ורק אם ההנחות בנוגע לטיפוסיות היו אכן נכונות. Dyalog APL נותנת תמיכה מלאה למיטובי בייטקוד עבור השפה.

=== הידור ===
[[הידור]] APL היה נושא למחקר וניסויים משחר הופעת השפה. המהדר הראשון עבור APL היה ה־*APL-700* מאת [[Burroughs]] שהושק בסביבות [[1971]]. כדי לאפשר הידור של APL נדרשות מגבלות מסוימות.

*APEX* הוא מהדר APL מחקרי שפותח על ידי רוברט בֶּרְנֶקִי (שהיה חלק מצוות הפיתוח של IPSA ו־Sharp APL) וזמין כ[[תוכנה חופשית]] תחת ה[[הרישיון הציבורי הכללי של גנו|רישיון הציבורי הכללי של GNU]].

*STSC APL Compiler* (מהדר ל־APL מאת STSC, המפתחת של APL*Plus) מבצע שילוב של מיטוב בייטקוד והידור, אך לא הידור מלא. הוא מאפשר הידור ל[[שפת מכונה]] רק עבור פונקציות שכל שאר הפונקציות והמשתנים שהן תלויות בהם כבר הוכרזו וידועים מראש. אך [[מפרש (תוכנה)|המפרש]] עדיין מספק את כל הפונקציות והפעולות עבור ספריית הליבה של השפה, ומשמש כנסיגה עבור פונקציות שאינן עומדות בתנאים הנחוצים להידור.

== תקינה ==
APL עברה תקינה על ידי [[קבוצת עבודה|קבוצת העבודה]] *X3J10* מטעם [[מכון התקנים האמריקני]] (ANSI) על ידי [[ארגון התקינה הבינלאומי]] (ISO) וע"י [[הנציבות הבין-לאומית לאלקטרוטכניקה|הנציבות הבינלאומית לאלקטרוטכניקה]] (IEC) בוועדה הטכנית המשותפת של ISO/IEC מס' 1, תת־ועדה מס' 22, קבוצת עבודה מס' 3. ליבת APL מאופיינת ב־*ISO 8485:1989*, ו־APL המורחבת מאופיינת ב־*ISO/IEC 13751:2001''.

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

* TryAPL.org - מפרש APL לניסוי השפה זמין מהדפדפן.
* APL Wiki - אתר הויקי של APL.

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

קטגוריה:שפות תכנות פונקציונליות
קטגוריה:שפות תכנות