Brontekst bekijken van APL (programmeertaal)

{{Infobox programmeertaal
| naam = APL
| logo = 
| extensies = 
| paradigma = [[Functionele programmeertaal|functioneel]], [[Multi-paradigmaprogrammeertaal|multi-paradigma]]
| jaar = 1962-1964
| ontwerper = [[Kenneth Eugene Iverson]]
| ontwikkelaar = [[Kenneth Eugene Iverson]]
| versie = 
| typesystem = dynamisch
| implementaties = IBM APL2, Dyalog APL, APL2000, Sharp APL
| dialecten = [[A+ (programmeertaal)|A+]] en anderen
| beinvloed = wiskundige notatie
| invloed = [[J (programmeertaal)|J]], [[K (programmeertaal)|K]]
| besturingssysteem = 
| licentie = 
| website = 
}}
'''APL''' is een [[programmeertaal]]. De taal is ontstaan uit een boek dat in [[1962]] werd geschreven door [[Kenneth Eugene Iverson|Kenneth E. Iverson]] en waarin een wiskundige notatiewijze werd geïntroduceerd. Met enkele aanpassingen werd uit dit voorstel de programmeertaal ontworpen. De naam APL is ontleend aan de titel van het boek: '''''A''' '''P'''rogramming '''L'''anguage''.

== Korte geschiedenis ==
=== Ontwikkelingen in de tijd ===
Zoals gezegd, de taal is ontstaan naar aanleiding van de publicatie van [[Kenneth Eugene Iverson|Kenneth E. Iverson]]. Hoewel zijn boek in [[1962]] uitkwam, ontdekte en ontwikkelde hij de taal al in [[1957]].
Als programmeertaal werd APL al snel populair in vooral de wetenschappelijke en financiële wereld vanwege de krachtige mogelijkheden die de taal biedt om om te gaan met meer-dimensionale arrays met data.
Oorspronkelijk draaide APL op ([[IBM]])-[[mainframe]]s en over de loop van jaren ontstonden er verschillende dialecten van de taal.
Na de opkomst van de [[Personal computer|pc]] begin jaren 80 van de twintigste eeuw, en de afname van de populariteit van [[mainframe]]s kwam er een versie van APL uit voor de pc onder de naam '''APL*Plus/PC''' van ontwikkelaar STSC ''(zie eventueel: [[:en:STSC|STSC (Engels)]])''. De eerste versie voor de pc kwam in [[1982]] op de markt en in het midden van de jaren 80 kwam er ook een 32-bit versie voor de [[Unix]] systemen op de markt als '''APL*Plus/Unix''').
Tot [[1995]] bleef STSC APL*Plus verder ontwikkelen, maar verkocht de rechten in dat jaar aan '''LEX2000 Inc.''' wat vervolgens in [[1999]] weer in handen kwam van [[Cognos]].
De belangstelling voor en het gebruik van APL zijn de laatste jaren erg teruggelopen, natuurlijk mede onder invloed van de komst van nieuwe ontwikkelomgevingen als [[C (programmeertaal)|C]] (en de opvolgers C+ / [[C++]]) en later [[Java (programmeertaal)|Java]]). Er bestaat nog wel een groep ''die-hards'' die APL en varianten/dialecten als A+<ref>Projectsite A+: [http://www.aplusdev.org/ Homepage A+]. [https://web.archive.org/web/20160122195959/http://www.aplusdev.org/ Gearchiveerd] op 22 januari 2016.</ref> gebruiken en ontwikkelen.

=== Van mainframe naar pc ===
De overgang naar de nieuwe [[Personal computer|pc]]-omgeving vereiste natuurlijk wel wat toevoegingen om op een nieuwe manier om te gaan met –vooral– de uitvoer van gegevens en andere specifieke ''eigenaardigheden'' van de [[Personal computer|pc]]. De eerste versies draaiden (uiteraard) onder [[MS-DOS]] en dat waren specifiek single-user- en single-taskomgevingen. Dit vraagt een heel andere benadering van geheugengebruik, en commando's die verband houden met je rechten hoeveel gebruik jouw programma mag maken van de [[CPU]] hebben weinig nut. Om portering van bestaande programma's van [[mainframe]]omgevingen naar de pc te vereenvoudigen bleven in de pc-versie commando's en functies bestaan die feitelijk niets deden, maar wel de compabiliteit van ''workspaces'' verhoogden. ''(Na de overstap van [[MS-DOS]] naar [[Microsoft Windows|Windows]] kwam je weer terug in een multi-user- en multi-taskingomgeving; maar wel op een andere wijze dan bij [[mainframe]]systemen.)''

=== Huidige situatie ===
Hoewel het gebruik sterk is teruggelopen, blijft er een enthousiaste groep gebruikers die via internet nieuwe ontwikkelingen gebaseerd op APL ontwikkelt.
* Vanaf [[2001]] bestaat het project Aplus of A+ dat vrij verkrijgbaar is onder de [[GNU General Public License]]. Het is in [[1998]] ontwikkeld door Arthur Whitney<ref>zie ook:[[:en:Arthur Whitney (computer scientist)|Arthur Whitney (in de Engelstalige Wiki)]]</ref> werkzaam bij de bank [[Morgan Stanley]]. Dit bedrijf had over de jaren - zoals veel vergelijkbare bedrijven - veel programmatuur ontwikkeld in APL. Omdat de banken afscheid namen van hun mainframes en gebruik gingen maken van systemen onder [[Solaris (besturingssysteem)|SunOS/Solaris]] zocht men een geschikte APL-omgeving daarvoor, maar die was niet beschikbaar. Omdat het bedrijf de bestaande tools in APL liever niet zou moeten afschaffen dan wel geheel opnieuw zouden moeten schrijven in een andere taal faciliteerden zij de ontwikkeling van A+ door Arthur Whitney en is de bank nog steeds sponsor van het project.<ref>Ontwikkelaar van A+ volgens [https://web.archive.org/web/20180925214228/http://www.aplusdev.org/About/index.html History of A+ pagina]. [https://web.archive.org/web/20160122195959/http://www.aplusdev.org/ Gearchiveerd] op 22 januari 2016.</ref>
* VisualAPL en APLNext: nieuwe versies van APL speciaal geschikt voor [[.NET]] omgevingen.<ref>Website van APLNext [https://web.archive.org/web/20090428135806/http://www.aplnext.com/vapl/default.aspx Visual APL pagina]</ref>
* DialogAPL, een moderne versie van APL voor verschillende Windows en Linux/Unix platformen.<ref>[http://www.dyalog.com/products.htm Dialog producten]. [https://web.archive.org/web/20210612000331/https://www.dyalog.com/products.htm Gearchiveerd] op 12 juni 2021.</ref>
* IBM APL2: een interpreter voor IBM systemen.<ref>[https://www-01.ibm.com/software/awdtools/apl/ APL software van IBM]. [https://web.archive.org/web/20130622183701/https://www-01.ibm.com/software/awdtools/apl/ Gearchiveerd] op 22 juni 2013.</ref>
* MVT4APL: gebruikt een emulator om APL\360 op de pc te kunnen draaien. Hiervoor is de broncode van APL\360 nodig, die gedownload mag worden als men met de voorwaarden akkoord gaat.<ref>[http://wotho.ethz.ch/mvt4apl-2.00/ MVT 4 APL - een emulator van APL\360 op de pc]. [https://web.archive.org/web/20211231101926/http://wotho.ethz.ch/mvt4apl-2.00/ Gearchiveerd] op 31 december 2021.</ref>

== Verschillen ==
De programmeertaal verschilt in veel opzichten van andere talen.
* Alle ingebouwde functies worden voorgesteld door een teken. De gebruikelijke tekens '''+''' en '''−''' voor [[optellen]] en [[aftrekken (wiskunde)|aftrekken]] zijn normaal aanwezig, maar ook voor andere functies, zoals [[faculteit (wiskunde)|faculteit]], [[logaritme]] en [[sinus en cosinus|sinus]], worden tekens gebruikt. Een APL-programma kan dan ook niet in [[ASCII (tekenset)|ASCII]] gecodeerd worden, maar wel in [[UNICODE]] (vanaf 2336h). 
* Er zijn geen sleutelwoorden zoals ''if'' en ''for''. Alle voorwaardelijke instructies worden uitgedrukt met de sprongopdracht (voorgesteld door het teken '''→''' ) met daarachter een expressie die geëvalueerd wordt naar een regelnummer.
* Letters worden alleen gebruikt om [[Identifier (programmeren)|identifier]]s te maken. De enige uitzondering is de letter '''''E''''', die ook wordt gebruikt in een getal met [[Zwevendekommagetal|zwevende komma]]. Verder worden letters gebruikt voor systeemopdrachten, zoals LOAD en SAVE, maar die maken geen deel uit van de taal.
* Er is een apart minteken '''¯''' voor negatieve getallen, terwijl voor aftrekken en negatie het gewone minteken '''−''' wordt gebruikt. Wellicht is APL de enige programmeertaal waarin een negatief getal niet als expressie wordt ingevoerd. Er is verschil tussen '''¯5+8''' = '''(¯5)+8''' = '''3''' en '''−5+8''' = '''−(5+8)''' = '''¯13'''. Schrijft men '''12 18 ¯5''' dan is dat een vector van drie getallen, en '''12 18 −5''' is een expressie die berekend wordt tot '''7 13'''.
* In expressies wordt er geen gebruik gemaakt van de gebruikelijke [[bewerkingsvolgorde]] van operatoren. Een expressie wordt strikt van rechts naar links uitgevoerd (tenzij er haakjes zijn gebruikt). Vermenigvuldigen heeft dus geen voorrang boven optellen en aftrekken. De expressie '''2×6+3''' geldt in APL als '''2×(6+3)''' = '''18''', niet als '''(2×6)+3''' = '''15''' zoals dat in andere programmeertalen en de wiskunde het geval is. Een vector geldt als eenheid, dus '''12 18 − 5''' = '''(12 18) −5''' = '''7 13'''.
* Er zijn geen expliciete declaraties. Door een hele array toe te kennen aan een identifier, wordt er geheugenruimte voor die identifier gereserveerd, voldoende ruimte voor de hele array.
* Hele arrays worden ineens verwerkt. Er zijn functies die een hele array kunnen maken of kopiëren, of die een bewerking kunnen uitvoeren op een array als geheel.
* De taal is niet gestructureerd. Dat wordt tegenwoordig als een nadeel gezien. De beginselen van het [[gestructureerd programmeren]] waren nog niet gebruikelijk in de tijd dat de taal ontworpen werd. Evenwel, doordat de taal hele arrays ineens verwerkt, is het zelden nodig een iteratie te gebruiken.

Een groot voordeel van APL is dus dat er heel compact en snel gecodeerd kan worden. Tegelijkertijd is dat een nadeel. Een APL-source is vaak lastig te lezen vanwege de vele vreemde tekens.

== Invoer ==
[[Bestand:APL-toetsenbord.png|600px|thumb|Het toetsenbord van een IBM 2741, met APL-tekens. Daaronder de combinaties die kunnen worden gemaakt met behulp van de BS-toets.]]
Voor het invoeren van APL-symbolen is een speciaal [[Toetsenbord (computer)|toetsenbord]] nodig. Het getoonde toetsenbord heeft geen aparte hoofd- en kleine letters: de lettertoetsen geven in combinatie met Shift een symbool.

En nog heeft het toetsenbord te weinig toetsen. Daarom kunnen er ook combinaties (overstrikes) worden gemaakt. Wenst men bijvoorbeeld een uitroepteken om de functie faculteit uit te voeren, dan typt men een aanhalingsteken (shift&nbsp;K), een backspace en een punt. Op dezelfde wijze kunnen ook de letters (andere tekens niet) onderstreept worden.

Er zijn verder diverse APL-editors. Om invoer te vergemakkelijken kan men van veel symbolen de naam invoeren.

== Gegevens ==
Gegevens kunnen, zoals bij elke programmeertaal, uit arrays bestaan. Maar bij APL wordt een array als eenheid beschouwd. Een array kan een willekeurig aantal dimensies hebben. Een array van twee dimensies heet 'matrix', een array van een dimensie heet 'vector'. Een array van nul dimensies bestaat ook, dat is een scalar.

De dimensie van een array kan desnoods de lengte nul of één hebben. Dat lijkt niet erg zinvol, maar een array met een dergelijke dimensie kan door een programma uitgebreid worden.

Een vector (2 of langer) kan als constante worden ingevoerd als een reeks getallen met spaties ertussen, bijvoorbeeld {{nowrap|'''1 4 9 16 25'''}}. Geeft men een enkel getal op, dan is dat een scalar. Wil men een andere array, dan zal men een functie moeten gebruiken.

De bekendste functie om een array te maken is ''reshape'' '''⍴'''. Bijvoorbeeld, de expressie {{nowrap|'''2 4⍴9 8 1 12 16 25 14 14'''}} maakt een matrix van 2 bij 4, met de daarachter opgegeven getallen als waarden.

Een andere veel gebruikte functie is de ''indexgenerator'' '''⍳''' die een vector van natuurlijke getallen maakt. '''⍳5''' levert dus de vector {{nowrap|'''1 2 3 4 5'''}}. Het ziet er niet erg zinvol uit, maar deze functie is vaak heel handig.

De meeste functies zijn erg vergevingsgezind als een argument de verkeerde vorm heeft. Bijvoorbeeld, de hierboven genoemde functie '''⍴''' heeft als linkerargument in principe een vector nodig, maar een scalar is ook goed.

Een array kan, zoals in elke programmeertaal, geïndiceerd worden: '''''A''[''I'']'''. Zijn er twee of meer indices, dan worden ze gescheiden door ''';'''. Het is beslist niet nodig dat op deze wijze een enkele waarde uit een array wordt gehaald: door een array als index te gebruiken of een index weg te laten is het mogelijk een deel uit een array te selecteren: de expressie {{nowrap|'''''R''[;3 4]'''}} heeft als resultaat een matrix bestaande uit de derde en de vierde kolom van de matrix '''''R''''' — de hele kolommen omdat de eerste index, tussen '''[''' en ''';''' is weggelaten.

Het is zelfs mogelijk een constante vector te indiceren, bijvoorbeeld '''1 3 8 5[''I'']'''.

== Voorbeeld ==
Onderstaande regel is een programma dat alle [[priemgetal]]len van 1 tot R vindt:

'''(∼''R''ε''R''∘.×''R'')/''R''←1↓⍳''R'''''

en de beschrijving van rechts naar links:
# '''⍳''R''''' maakt een vector met gehele getallen van '''1''' t/m '''''R''''', dus {{nowrap|'''1 2 3 4 5'''}} als '''''R''=5'''
# '''1↓''' 'drop' laat eerste getal weg: '''2 3 4 5'''
# '''←''' [[assignment operator]]: dus '''''R''''' is nu '''2 3 4 5'''
# '''∘.×''' [[uitproduct]] van '''''R''''' en '''''R''''': dit resulteert in de matrix:<br />'''{{0}}4 {{0}}6 {{0}}8 10'''<br />'''{{0}}6 {{0}}9 12 15'''<br />'''{{0}}8 12 16 20'''<br />'''10 15 20 25'''
# '''ε''' onderzoekt van elk getal in de linker parameter '''2 3 4 5''' of het in de rechter parameter (de matrix) voorkomt. Alleen de '''4''' komt voor, dus het resultaat is: false false true false (in werkelijkheid '''0 0 1 0''')
# '''∼''', negatie: dus '''1 1 0 1'''
# '''/''': selecteer: aan de hand van de vector '''1 1 0 1''' worden getallen geselecteerd uit de vector '''''R''''', dus {{nowrap|'''2 3 4 5'''}}. Het resultaat is de vector {{nowrap|'''2 3 5'''}}. Daarmee is het probleem opgelost.

== Functies ==
Er zijn monadische functies met één argument en dyadische functies met twee argumenten. De syntaxis is zoals gebruikelijk bij de klassieke wiskundige functies, bijvoorbeeld '''''A''+''B''''' en '''−''B'''''. Deze syntaxis is consequent doorgevoerd voor alle functies, ook voor faculteit (uitroepteken links van de operand, niet rechts) en absolute waarde (verticale streep links van de operand, niet aan weerszijden).

Verder worden de functies onderscheiden in scalaire functies en gemengde functies. De laatste zijn in het bijzonder bedoeld voor het werken met arrays.

=== Scalaire functies ===
Worden scalaire functies op een array toegepast, dan werken ze op ieder element van de array apart. Men kan bijvoorbeeld twee arrays bij elkaar optellen, mits beide arrays dezelfde vorm hebben, dus arrays van evenveel dimensies met dezelfde waarden. Het resultaat heeft weer dezelfde vorm. Bijvoorbeeld: {{nowrap|'''3 5 4 + 2 4 6'''}} geeft {{nowrap|'''5 9 10'''}}. Hierop geldt een uitzondering: men kan een scalaire dyadische functie uitvoeren op twee arrays waarvan een enkel getal is. Bijvoorbeeld: {{nowrap|'''3 + 2 4 6'''}} geeft {{nowrap|'''5 7 9'''}}.

{| class="wikitable"
!Teken||Math||Unicode (hex)||{{Witte kolom|13}}||colspan="2"|Dyadisch||{{Witte kolom|13}}||colspan="2"|Monadisch
|-
|align=center|'''+'''|| || ||Plus||Optelling||Plus||onveranderd
|-
|align=center|'''−'''|| || ||Min||Aftrekking||Min||Negatie
|-
|align=center|'''×'''||\times|| ||Maal||Vermenigvuldiging||Teken||'''1''' als argument positief is, '''¯1''' als argument negatief is, '''0''' als argument nul is
|-
|align=center|'''÷'''||\div|| ||Delen||Deling||Omgekeerde||Omgekeerde
|-
|align=center|'''⌈'''|| ||2308||Maximum||Het grootste der twee argumenten||Ceiling||Het kleinste gehele getal dat niet kleiner is dan het argument
|-
|align=center|'''⌊'''|| ||230a||Minimum||Het kleinste der twee argumenten||Floor||Het grootste gehele getal dat niet groter is dan het argument
|-
|align=center|'''*'''|| ||2217||Machtsverheffen||A in de macht B||e-macht||Macht van e
|-
|align=center|'''⍟'''||\circledast|| ||Logaritme||Logaritme van B met grondtal A||colspan=2|Natuurlijke logaritme
|-
|align=center|'''|'''|| || ||Rest||Rest bij deling van B door A||colspan=2|Absolute waarde
|-
|align=center|'''!'''|| || ||Binomiaalcoëfficiënt||<math>B \choose A</math>
|Faculteit||Faculteit (of gammafunctie van B+1)
|-
|align=center|'''?'''|| || ||colspan=2|zie gemengde functies||Willekeurig||Willekeurig getal uit '''⍳''B'''''
|-
|align=center|'''ο'''||\circle ||2394 ||trigonometrische functies||het linker argument (tussen '''¯7''' en '''7''') bepaalt welke functie wordt uitgevoerd
|pi maal||product van pi
|-
!colspan="9"|Logische functies: enige toegestane argumenten zijn '''1''' (true) en '''0''' (false)
|-
|align=center|'''∧'''||\land||22c0||{{Witte kolom|5}}||En||||{{Witte kolom|5}}||||
|-
|align=center|'''∨'''||\lor||22c1||Of||||||
|-
|align=center|'''⍲'''|| ||2372||Niet en||||||
|-
|align=center|'''⍱'''|| ||2371||Niet of||||||
|-
|align=center|'''∼'''||\sim|| |||| ||Niet||Verandert '''1''' in '''0''' en '''0''' in '''1'''
|-
!colspan="9"|Vergelijkingen: het resultaat is '''1''' (true) of '''0''' (false)
|-
|align=center|'''<''' || || ||{{Witte kolom|6}}||kleiner||rowspan=4|Kan alleen op getallen worden toegepast||{{Witte kolom|6}}||||
|-
|align=center|'''≤''' ||\le||2264||kleiner of gelijk||||
|-
|align=center|'''>''' || || ||groter||||
|-
|align=center|'''≥''' ||\ge||2265||groter of gelijk||||
|-
|align=center|'''=''' || || ||gelijk||rowspan=2|Kan op getallen en tekens worden toegepast||||
|-
|align=center|'''≠''' ||\ne||2260||ongelijk||||
|}

=== Gemengde functies ===
Gemengde functies zijn speciaal voor het bewerken van arrays. Sommige functies kunnen zelfs van een index worden voorzien. Bijvoorbeeld '''''A''↑[''I'']''B'''''. In dit geval wordt de functie '''''A''↑''B''''' langs de index '''''I''''' uitgevoerd. De index is dus een geheel getal, behalve bij de functie Lamination. Wordt er geen index opgegeven, dan wordt de functie langs de laatste dimensie uitgevoerd.
{| class="wikitable"
!Teken||Math||Unicode (hex)||{{Witte kolom|18}}||colspan="2"|Dyadisch||{{Witte kolom|18}}||colspan="2"|Monadisch
|-
|align=center|'''⍴'''|| ||2374||Reshape||Maak een array. het linkerargument bepaalt de vorm van de array, de waarden van de array komen uit het rechterargument.
|Dimensie||Maakt een vector met de vorm van het rechterargument.
|-
|align=center|'''⍳'''|| ||2373||Zoeken||Zoekt de waarden van het rechterargument in het linkerargument en geeft terug op welke positie de waarden voorkomen. Het linker argument moet een vector zijn.
|Index||Maakt een vector met de natuurlijke getallen van 1 tot ''n''.
|-
|align=center|''','''|| || ||Catenation (indiceerbaar)||Een komma koppelt twee arrays aan elkaar tot een nieuwe array. Alle dimensies van de twee arrays moeten identiek zijn, behalve de dimensie waarlangs de functie wordt uitgevoerd. 
|Ravel||Een monadische komma maakt een vector van het argument.
|-
|align=center|''','''|| || ||Lamination (de index is verplicht en moet een gebroken getal zijn, uitzondering: als beide argumenten scalair zijn is geen index nodig)||Koppelt twee arrays aan elkaar tot een nieuwe array. Alle dimensies van de twee arrays moeten identiek zijn, en de nieuwe array heeft een dimensie meer, met de waarde 2. Voor deze functie is een gebroken index nodig. Bijvoorbeeld '''''A'',[3.5]''B''''' koppelt de arrays tussen de derde en vierde dimensie aan elkaar.
|-
|align=center|'''↑'''||\uparrow||2191 ||Take (indiceerbaar)||Neemt een deel uit het tweede argument, namelijk zo veel elementen als door het tweede argument is aangegeven. Is het eerste argument positief, dan worden de eerste N elementen genomen, is het negatief, dan worden de laatste −N elementen genomen.
|-
|align=center|'''↓'''||\downarrow||2193 ||Drop (indiceerbaar)||Verwijdert een deel uit het tweede argument, namelijk zo veel elementen als door het tweede argument is aangegeven. Is het eerste argument positief, dan worden de eerste N elementen verwijderd, is het negatief, dan worden de laatste −N elementen verwijderd.
|-
|align=center|'''/'''|| || ||Compressie (indiceerbaar)||Het linker argument is een logische vector. De waarden die met een nul corresponderen worden uit het rechter argument verwijderd. Bijvoorbeeld 1 0 1 0 / 2 3 5 4 resulteert in 2 5. 
|colspan=2|Het teken '''/''' kan niet monadisch worden gebruikt, maar vormt dan met het voorafgaande teken een gecombineerde functie. Zie volgende tabel.
|-
|align=center|'''⌿'''|| ||233f||Compressie||Hetzelfde als '''/[1]'''
|-
|align=center|'''\'''|| || ||Expansie (indiceerbaar)||Het linker argument is een logische vector. In het rechterargument worden waarden tussengevoegd op de plaatsen die corresponderen met een nul in het linkerargument. Bijvoorbeeld 1 0 1 0 \ 2 5 resulteert in 2 0 5 0. 
|-
|align=center|'''⍀'''|| ||2340||Expansie||Hetzelfde als '''\[1]'''.
|-
|align=center|'''⍋'''|| ||23c3||colspan="2"| ||Grade up||Vector, zodanig dat '''''V''[⍋''V'']''' gesorteerd is.
|-
|align=center|'''⍒'''|| || ||colspan="2"| ||Grade down||Vector, zodanig dat '''''V''[⍒''V'']''' omgekeerd gesorteerd is.
|-
|align=center|'''⌽'''|| ||23c0, 233d||Roteren (indiceerbaar)||De volgorde van de elementen van het rechterargument wordt opgeschoven||Omkeren||Het rechterargument wordt andersom gezet
|-
|align=center|'''⊖'''|| || ||Roteren||Hetzelfde als '''⌽[1]'''||Omkeren||
|-
|align=center|'''⌹'''|| ||2339||Matrixdeling||Omgekeerde van inwendig matrixproduct||Inverse van matrix||
|-
|align=center|'''?'''||||||Deal||A getallen, willekeurig gekozen uit '''⍳''B'''''||colspan=2|zie scalaire functies
|-
|align=center|'''⌶'''|| ||2336||I beam||Diverse functies, alleen voor de systeembeheerder, sommige met neveneffecten. Onder andere "peek" en "poke" in het geheugen, systeem afsluiten.
|I beam||Diverse systeeminformatie, zoals datum, tijd, geheugenruimte, aantal aangemelde gebruikers. Voor de systeembeheerder zijn er nog meer mogelijkheden.
|}

=== Gecombineerde functies ===
Verder zijn er gecombineerde functies. Hierbij wordt uit een scalaire dyadische functie (of twee scalaire dyadische functies) een nieuwe gemengde functie gemaakt. In de voorbeelden hieronder kan '''⎕''' worden vervangen door een willekeurige scalaire dyadische functie.
{| class="wikitable"
!Teken||Math||Unicode (hex)||{{Witte kolom|5}}||colspan="2"|Dyadisch||{{Witte kolom|5}}||colspan="2"|Monadisch
|-
|align=center|'''⎕/''B'''''|| || ||||||Reductie||De dyadische functie '''⎕''' wordt toegepast op de hele vector, bijvoorbeeld '''+/3 5 8''' komt overeen met '''3+5+8'''
|-
|align=center|'''⎕⌿''B'''''|| ||233f||||||||Hetzelfde als '''⎕/[1]''B'''''
|-
|align=center|'''''A''∘.⎕''B'''''|| ||2218||Uitwendig product||Uitwendig product van twee arrays. Elke dyadische scalaire functie kan als '''⎕''' worden gebruikt.
|-
|align=center|'''''A''⎕.⎕''B'''''|| || ||Inwendig product||Het gewone matrixproduct is '''''A''+.×''B'''''
|}

=== Oneigenlijke functies ===
{| class="wikitable"
!Teken||Math||Unicode (hex)||{{Witte kolom|3}}||colspan="2"|Dyadisch||{{Witte kolom|3}}||colspan="2"|Monadisch
|-
|align=center|'''←'''||\gets||2190||toekenning||Het linker argument is een variabele die de waarde krijgt van het rechter argument
|-
|align=center|'''→'''||\to||2192 ||colspan=2| ||sprongopdracht||De uitvoering van het programma gaat verder op het aangegeven regelnummer. Is het argument een array, dan geldt het eerste element van de array. Is het argument een lege array, dan gaat de uitvoering verder met de volgende regel. Door expressies te gebruiken zijn voorwaardelijke sprongen mogelijk. Wordt naar regel nul gesprongen, dan wordt de uitvoering van de routine beëindigd.
|}

== In- en uitvoer ==
De laatste bewerking die op een regel wordt uitgevoerd, is vrijwel steeds '''→''' (sprongopdracht) of '''←''' (toekenning).

Bijvoorbeeld:<br />
'''→3+5''' spring naar regel 8<br />
'''''A''←3+5''' '''''A''''' krijgt de waarde 8

Staat er iets anders, bijvoorbeeld '''3+5''', dan wordt de optelling uitgerekend, maar er staat niet wat er met het resultaat moet gebeuren. In dat geval wordt het resultaat geprint.

Het is ook mogelijk tussenresultaten van een expressie te printen, en wel met de combinatie '''⎕←'''. Bijvoorbeeld: '''''A''←3+⎕←5''' De waarde 5 wordt geprint en '''''A''''' krijgt de waarde 8.

Wil men in de loop van het programma invoer vragen, dan gebruikt men het teken '''⎕''', maar niet links van een pijltje. Bijvoorbeeld '''2.20371×⎕''': er wordt om invoer gevraagd en het resultaat wordt met 2.20371 vermenigvuldigd.

== Zelfgedefinieerde functies ==
Het is natuurlijk mogelijk zelf een functie te definiëren. Een zelfgedefinieerde functie kan dyadisch, monadisch en ook niladisch zijn, dat wil zeggen dat er 2, 1, of 0 argumenten zijn.

Een zelfgedefinieerde functie wordt niet aangeduid met een teken maar met een naam, een identifier dus. De syntaxis is echter niet anders: een dyadische functie wordt aangeroepen met de naam en aan weerszijden de beide argumenten en een monadische functie met de naam en daarachter het argument. Deze wijze van aanroepen is heel anders dan in andere programmeertalen.

Als voorbeeld geven we de volgende functie. Het teken '''∇''' duidt de header van de functie aan. Daaronder staat de body, in dit geval slechts een regel, met daarvoor tussen haken het regelnummer.

'''∇''SOM''←''U''  ''VREL''  ''V'''''<br />
'''[1] ''SOM''←(''U''+''V'')÷1+(''U''×''V'')÷9''E''16'''

In de kopregel staat links van het pijltje de variabele die als terugkeerwaarde dient. Rechts daarvan staan drie namen, het is dus een dyadische functie. De middelste daarvan is de naam van de functie en de twee andere zijn de argumenten.

== Opslag van data en programma's ==
APL gaat op een bijzondere manier om met opslag van zowel de gegevens alsook de programmabroncode zelf in vergelijking met veel andere talen.
Je kunt drie soorten bestanden onderscheiden:
* Workspacefiles: hierin sla je de programmacode op. Standaard is APL een interpretertaal, dus de commando's worden pas op het moment van uitvoering omgezet in machinecode. In de pc-versies van APL hebben deze files de extensie .AWS.
* APL-datafiles: als je data zoals variabelen wilt opslaan op disk (dan wel wilt lezen vanaf harddisk) gebruik je normaliter de eigen filestructuur van APL, herkenbaar aan de extensie .ASF. Als je data wilt opvragen uit een dergelijk bestand dan alloceer (in APL '''"TIE"''' genoemd) je zo'n bestand en koppel je dat aan een nummer. De gegevens zelf zijn vervolgens geïndexeerd opgeslagen. Als je data toevoegt wordt een nieuw indexnummer of segment toegevoegd. Later kun je verwijzen naar die data met het TIE-nummer en het indexnummer. Je kunt die data dan lezen, herschrijven/vervangen of verwijderen.
:Elk segment kan één variabele bevatten, maar dat kan van alles zijn. Bijvoorbeeld een alfanumerieke string of een driedimensionale matrix met alleen integers enz. In één file kun je per segment elk type data opslaan.
* Native-files: dit zijn alle andere bestanden, maar meestal ASCII- of tekstbestanden. De extensie is irrelevant – daar wordt niets mee gedaan. Net als ASF-files krijgen ze '''TIE'''-en en een (negatief) nummer. Het lezen van gegevens doe je met een leescommando waarbij je als argumenten het TIE-nummer geeft gevolgd door type data, het startpunt en de hoeveelheid te lezen gegevens. Via het type argument geef je aan of je de gegevens moet interpreteren als alfanumerieke karakters, integers, reële getallen enz. In de praktijk wordt de eerste soort gebruikt en werk je met leesbare tekst. Het startpunt en de lengte druk je uit in bytes. Als voorbeeld kun je dus van een tekstbestand expliciet 100 tekens inlezen vanaf het 80e karakter. Schrijven naar native-bestanden kan of door toevoeging van data aan het einde van het bestaande bestand of door - net al bij lezen - expliciet op te geven vanaf welk karakter/byte de gegevens herschreven moeten worden.
:Als je in een APL-programma gegevens op harddisk wilt opslaan die alleen door (andere) APL-programma's gebruikt zullen worden kies je voor de eigen ASF-files, maar als je gegevens wilt kunnen uitwisselen met andere programma's gebruik je de native-files: je kunt bijvoorbeeld uitkomsten van APL-procedures wegschrijven naar een native-bestand in de vorm van een ''comma separated file'' zodat je die data later weer kunt inlezen in een [[Microsoft Excel|Excel]]-spreadsheet.

== Zie ook ==
* [[Lijst van programmeertalen]]

== Externe link ==
* {{en}}[https://web.archive.org/web/20090221171112/http://www.sigapl.org/whyapl.htm Waarom APL?]  

{{Appendix}}
{{commonscat|APL (programming language)|APL}}
{{Navigatie programmeertalen}}

[[Categorie:Programmeertaal|APL]]
[[Categorie:Imperatief programmeren]]