Editing APL (programming language) (section)

== Language characteristics ==
=== Character set ===
{{Main|APL (codepage)|APL syntax and symbols#Monadic functions|l2=syntax and symbols}}

APL has been criticized and praised for its choice of a unique character set. In the 1960s and 1970s, few terminal devices or even displays could reproduce the APL character set. The most popular ones employed the [[IBM Selectric]] print mechanism used with a special APL type element. One of the early APL [[computer terminal|line terminals]] (line-mode operation only, ''not'' full screen) was the Texas Instruments TI Model 745 ({{circa|1977}}) with the full APL character set<ref>{{cite journal |author1=Texas Instruments |title=TI 745 full page ad: Introducing a New Set of Characters |journal=Computerworld |date=1977 |volume=11 |issue=27 |page=32 |url=https://books.google.com/books?id=wMe6erbb5V4C&q=apl%20terminal%20%22texas%20instruments%22&pg=PA32 |access-date=January 20, 2015}}</ref> which featured [[Duplex (telecommunications)|half and full duplex]] [[telecommunications]] modes, for interacting with an APL [[time-sharing]] service or remote mainframe to run a remote computer job, [[remote job entry]] (RJE).

Over time, with the universal use of high-quality graphic displays, printing devices and [[Unicode]] support, the APL character font problem has largely been eliminated. However, entering APL characters requires the use of [[input method editor]]s, keyboard mappings, virtual/on-screen APL symbol sets,<ref name="FontsKeys">{{cite web |author1=<!-- Unstated --> |date=2004–2024 |title=APL Fonts and Keyboards |url=https://www.dyalog.com/apl-font-keyboard.htm |website=Dyalog, Ltd. |access-date=November 1, 2024}}</ref><ref>{{cite web |last1=Smith |first1=Bob |url=http://www.sudleyplace.com/APL/Keyboard.ahtml |title=NARS2000 Keyboard |website=www.sudleyplace.com |publisher=Bob Smith; NARS2000 |access-date=January 19, 2015}}</ref> or easy-reference printed keyboard cards which can frustrate beginners accustomed to other programming languages.<ref>{{cite web |title=Introduction to APL – APL Symbols |website=www.microapl.co.uk |publisher=MicroAPL Ltd |url=http://www.microapl.co.uk/apl/introduction_chapter1.html |access-date=January 8, 2015}}</ref><ref>{{cite journal |last1=Brown |first1=James A. |last2=Hawks |first2=Brent |last3=Trimble |first3=Ray |date=1993 |title=Extending the APL character set |journal=ACM SIGAPL APL Quote Quad |volume=24 |issue=1 |pages=41–46 |doi=10.1145/166198.166203}}</ref><ref>{{cite web |last1=Kromberg |first1=Morten |title=Unicode Support for APL |url=http://archive.vector.org.uk/art10500090 |website=archive.vector.org.uk |publisher=Vector, Journal of the British APL Association |access-date=January 8, 2015 |archive-url=https://web.archive.org/web/20150120194338/http://archive.vector.org.uk/art10500090|archive-date=January 20, 2015 |url-status=dead}}</ref> With beginners who have no prior experience with other programming languages, a study involving high school students found that typing and using APL characters did not hinder the students in any measurable way.<ref>{{cite web |last1=Hsu |first1=Aaron |title=Computer Science Outreach and Education with APL |url=http://video.dyalog.com/Dyalog13/?v=kIItfQJEVdM |publisher=Dyalog, Ltd. |access-date=July 15, 2016 |archive-date=August 17, 2016 |archive-url=https://web.archive.org/web/20160817061145/http://video.dyalog.com/Dyalog13/?v=kIItfQJEVdM |url-status=dead}}</ref>

In defense of APL, it requires fewer characters to type, and keyboard mappings become memorized over time. Special APL keyboards are also made and in use today, as are freely downloadable fonts for operating systems such as Microsoft Windows.<ref name="FontsKeys"/> The reported productivity gains assume that one spends enough time working in the language to make it worthwhile to memorize the symbols, their semantics, keyboard mappings, and many idioms for common tasks.{{citation needed|date=July 2015}}

=== Design ===
Unlike traditionally structured programming languages, APL code is typically structured as chains of [[Unary operation|monadic]] or [[Binary operation|dyadic]] [[Function (computer programming)|functions]], and [[Higher-order function|operators]]<ref name="MicroAOL_Operators">{{cite web|last1=MicroAPL|title=Operators|url=http://www.microapl.co.uk/apl/apl_concepts_chapter5.html|website=www.microapl.co.uk|publisher=MicroAPL|access-date=January 12, 2015}}</ref> acting on [[array data type|arrays]].<ref>{{cite web|last1=Primitive Functions|title=Primitive Functions|url=http://www.microapl.co.uk/apl_help/ch_020_010_140.htm|website=www.microapl.co.uk/|access-date=January 1, 2015}}</ref> APL has many nonstandard ''primitives'' (functions and operators) that are indicated by a single symbol or a combination of a few symbols. All primitives are defined to have the same [[operator precedence|precedence]], and always associate to the right. Thus, APL is ''read'' or best understood from [[APL syntax and symbols#Syntax rules|right-to-left]].

Early APL implementations ({{circa|1970}} or so) had no programming loop [[control flow]] structures, such as <code>do</code> or <code>while</code> loops, and <code>if-then-else</code> constructs. Instead, they used array operations, and use of [[structured programming]] constructs was often unneeded, since an operation could be performed on a full array in one statement. For example, the <code>iota</code> function (<code>ι</code>) can replace for-loop [[iteration]]: ιN when applied to a scalar positive integer yields a one-dimensional array (vector), 1 2 3&nbsp;... N. Later APL implementations generally include comprehensive control structures, so that data structure and program control flow can be clearly and cleanly separated.

The APL environment is called a ''workspace''. In a workspace the user can define programs and data, i.e., the data values exist also outside the programs, and the user can also manipulate the data without having to define a program.<ref>{{cite web|last1=Workspace|title=The Workspace|url=http://www.microapl.co.uk/apl/apl_concepts_chapter2.html|website=www.microapl.co.uk|access-date=January 1, 2015}}</ref> In the examples below, the APL interpreter first types six spaces before awaiting the user's input. Its own output starts in column one.
{| class="wikitable"
|-
| width="240pt" | <syntaxhighlight lang="apl">      n ← 4 5 6 7</syntaxhighlight>
| Assigns [[coordinate vector|vector]] of values, {4 5 6 7}, to variable <code>n</code>, an array create operation. An equivalent yet more concise APL expression would be <syntaxhighlight lang="apl" inline>n ← 3 + ⍳4</syntaxhighlight>. Multiple values are stored in array <code>n</code>, the operation performed ''without formal loops or control flow language''.
|-
| <syntaxhighlight lang="apl">      n 
4 5 6 7</syntaxhighlight>
| Display the contents of <code>n</code>, currently an array or vector.
|-
| <syntaxhighlight lang="apl">      n+4
8 9 10 11</syntaxhighlight>
| 4 is now added to all elements of vector <code>n</code>, creating a 4-element vector {8 9 10 11}.<br/> As above, APL's interpreter displays the result because the expression's value was not assigned to a variable (with a <code>←</code>).
|-
| <syntaxhighlight lang="apl">      +/n
22</syntaxhighlight>
| APL displays the sum of components of the vector <code>n</code>, i.e., <code>22 (= 4 + 5 + 6 + 7)</code> using a very compact notation: read +/ as "plus, over..." and a slight change would be "multiply, over..."
|-
| <syntaxhighlight lang="apl">      m ← +/3+⍳4
      m
22</syntaxhighlight>
| These operations can be combined into one statement, remembering that APL evaluates expressions right to left: first <syntaxhighlight lang="apl" inline>⍳4</syntaxhighlight> creates an array, <syntaxhighlight lang="apl" inline>[1,2,3,4]</syntaxhighlight>, then 3 is added to each component, which are summed together and the result stored in variable <code>m</code>, finally displayed. In normal mathematical notation, it is equivalent to: <math>\displaystyle m= \sum\limits_{i=1}^4 (i+3)</math>. Recall that mathematical expressions are not read or evaluated from right-to-left.
|}

The user can save the workspace with all values, programs, and execution status.

APL uses a set of non-[[ASCII]] symbols, which are an extension of traditional arithmetic and algebraic notation. Having single character names for single instruction, multiple data ([[Single instruction, multiple data|SIMD]]) vector functions is one way that APL enables compact formulation of algorithms for data transformation such as computing [[Conway's Game of Life]] in one line of code.<ref>{{cite web |url=http://catpad.net/michael/apl |title=example |publisher=Catpad.net |access-date=June 17, 2013 |url-status=dead |archive-url=https://web.archive.org/web/20130708114840/http://catpad.net/michael/apl/ |archive-date=July 8, 2013}}</ref> In nearly all versions of APL, it is theoretically possible to express any computable function in one expression, that is, in one line of code.{{citation needed|date=May 2021}}

Due to the unusual [[character set]], many programmers use special [[computer keyboard|keyboards]] with APL keytops to write APL code.<ref>{{cite web|title=Entering APL Symbols |url=http://www.microapl.co.uk/apl/introduction_chapter2.html |website=www.microapl.co.uk|access-date=January 1, 2015}}</ref> Although there are various ways to write APL code using only ASCII characters,<ref>{{cite web |last1=Dickey |first1=Lee |url= http://www.math.uwaterloo.ca/apl_archives/apl/translit.schemes |title=A list of APL Transliteration Schemes |archive-url=https://web.archive.org/web/20060929174125/http://www.math.uwaterloo.ca/apl_archives/apl/translit.schemes |archive-date=2006-09-29 |date=1993}}</ref> in practice it is almost never done. (This may be thought to support Iverson's thesis about [[Linguistic relativity|notation as a tool of thought]].<ref>{{cite journal |url=http://www.jsoftware.com/papers/tot.htm |last1=Iverson |first1=K.E. |title=Notation as a Tool of Thought |archive-url=https://web.archive.org/web/20130920071911/http://www.jsoftware.com/papers/tot.htm |archive-date=2013-09-20 |journal=Communications of the ACM |volume=23 |pages=444–465 |date=August 1980|issue=8 |doi=10.1145/358896.358899}}</ref>) Most if not all modern implementations use standard keyboard layouts, with special mappings or [[input method editor]]s to access non-ASCII characters. Historically, the APL font has been distinctive, with uppercase italic alphabetic characters and upright numerals and symbols. Most vendors continue to display the APL character set in a custom font.

Advocates of APL{{Who|date=March 2015}} claim that the examples of so-called ''write-only code'' (badly written and almost incomprehensible code) are almost invariably examples of poor programming practice or novice mistakes, which can occur in any language. Advocates also claim that they are far more productive with APL than with more conventional computer languages, and that working software can be implemented in far less time and with far fewer programmers than using other technology.{{citation needed|date=December 2019}}

They also may claim that because it is compact and terse, APL lends itself well to larger-scale software development and complexity, because the number of lines of code can be reduced greatly. Many APL advocates and practitioners also view standard programming languages such as [[COBOL]] and [[Java (programming language)|Java]] as being comparatively tedious. APL is often found where time-to-market is important, such as with trading systems.<ref>{{cite web |last1=Batenburg |title=APL Efficiency |url=http://www.ekevanbatenburg.nl/PRVAPL.HTML |website=www.ekevanbatenburg.nl |access-date=January 1, 2015}}</ref><ref>{{cite web |last1=Vaxman |title=APL Great Programming |url=http://www.vaxman.de/publications/apl_slides.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.vaxman.de/publications/apl_slides.pdf |archive-date=2022-10-09 |url-status=live |website=www.vaxman.de |access-date=January 1, 2015}}</ref><ref>{{cite journal |last1=Janko |first1=Wolfgang |title=Investigation into the efficiency of using APL for the programming of an inference machine |journal= ACM SIGAPL APL Quote Quad|date=May 1987 |volume=17 |issue=4 |pages=450–456 |doi=10.1145/384282.28372}}</ref><ref>{{cite web |last1=Borealis |title=Why APL? |url=http://www.aplborealis.com/whyapl.html |website=www.aplborealis.com |access-date=January 1, 2015}}</ref>

=== Terminology ===
APL makes a clear distinction between ''functions'' and ''operators''.<ref name="MicroAOL_Operators"/><ref>{{cite web |last1=Iverson |first1=Kenneth E. |author-link=Kenneth E. Iverson |year=1987 |title=A Dictionary of APL |url=http://www.jsoftware.com/papers/APLDictionary.htm |website=www.jsoftware.com |access-date=January 20, 2015}}</ref> Functions take arrays (variables or constants or expressions) as arguments, and return arrays as results. Operators (similar to [[higher-order function]]s) take functions or arrays as arguments, and derive related functions. For example, the ''sum'' function is derived by applying the ''reduction'' operator to the ''addition'' function. Applying the same reduction operator to the ''maximum'' function (which returns the larger of two numbers) derives a function which returns the largest of a group (vector) of numbers. In the J language, Iverson substituted the terms ''verb'' for ''function'' and ''adverb'' or ''conjunction'' for ''operator''.

APL also identifies those features built into the language, and represented by a symbol, or a fixed combination of symbols, as ''primitives''. Most primitives are either functions or operators. Coding APL is largely a process of writing non-primitive functions and (in some versions of APL) operators. However a few primitives are considered to be neither functions nor operators, most noticeably assignment.

Some words used in APL literature have meanings that differ from those in both mathematics and the generality of computer science.

{| class="wikitable"
|+Terminology of APL operators
|-
!scope="col"| Term
!scope="col"| Description
|-
!scope="row"| function
| operation or mapping that takes zero, one (right) or two (left & right) arguments which may be scalars, arrays, or more complicated structures, and may return a similarly complex result. A function may be:
* Primitive: built-in and represented by a single glyph;<ref name="aplxch6">{{cite web |url=http://www.microapl.co.uk/APL/apl_concepts_chapter6.html |title=APL concepts |publisher=Microapl.co.uk |access-date=February 3, 2010}}</ref>
* Defined: as a named and ordered collection of program statements;<ref name="aplxch6"/>
* Derived: as a combination of an operator with its arguments.<ref name="aplxch6"/>
|-
!scope="row"| array
| data valued object of zero or more [[orthogonal]] dimensions in [[Row- and column-major order|row-major]] order in which each item is a primitive scalar datum or another array.<ref>{{cite web |url=http://www.nial.com/ArrayTheory.html |title=Nested array theory |publisher=Nial.com |access-date=February 3, 2010 |archive-url=https://web.archive.org/web/20110709072354/http://www.nial.com/ArrayTheory.html |archive-date=2011-07-09 |url-status=dead}}</ref>
|-
!scope="row"| niladic
| not taking or requiring any arguments, nullary<ref name="Bohman_Froberg">"Programmera i APL", Bohman, Fröberg, [[Studentlitteratur]], {{ISBN|91-44-13162-3}}</ref>
|-
!scope="row"| monadic
| requiring only one argument; on the right for a function, on the left for an operator, unary<ref name="Bohman_Froberg"/>
|-
!scope="row"| dyadic
| requiring both a left and a right argument, binary<ref name="Bohman_Froberg"/>
|-
!scope="row"| ambivalent<br/>or&nbsp;monadic
| capable of use in a monadic or dyadic context, permitting its left argument to be elided{{Definition needed|date=February 2024}}<ref name="aplxch6"/>
|-
!scope="row"| operator
| operation or mapping that takes one (left) or two (left & right) function or array valued arguments (operands) and derives a function. An operator may be:
* Primitive: built-in and represented by a single glyph;<ref name="aplxch6"/>
* Defined: as a named and ordered collection of program statements.<ref name="aplxch6"/>
|}

=== Syntax ===
{{Main|APL syntax and symbols}}
APL has explicit representations of functions, operators, and syntax, thus providing a basis for the clear and explicit statement of extended facilities in the language, and tools to experiment on them.<ref>{{cite web |last1=Iverson |first1=Kenneth E. |author-link=Kenneth E. Iverson |title=APL Syntax and Semantics |url=http://www.jsoftware.com/papers/APLSyntaxSemantics.htm |website=www.jsoftware.com |date=1983 |publisher=I. P. Sharp Associates |access-date=January 11, 2015}}</ref>

=== Examples ===
==== Hello, world ====
This displays "[[Hello, world]]":

<syntaxhighlight lang="apl">
'Hello, world'
</syntaxhighlight>

A design theme in APL is to define default actions in some cases that would produce syntax errors in most other programming languages.

The 'Hello, world' string constant above displays, because display is the default action on any expression for which no action is specified explicitly (e.g. assignment, function parameter).

==== Exponentiation ====
Another example of this theme is that exponentiation in APL is written as {{code|2*3}}, which indicates raising 2 to the power 3 (this would be written as {{code|2^3}} or {{code|2**3}} in some languages, or relegated to a function call such as {{code|pow(2, 3);}} in others). Many languages use {{code|*}} to signify multiplication, as in {{code|2*3}}, but APL chooses to use {{code|2×3}}. However, if no base is specified (as with the statement {{code|*3}} in APL, or {{code|^3}} in other languages), most programming languages one would see this as a syntax error. APL, however, assumes the missing base to be the natural logarithm constant [[e (mathematical constant)|e]], and interprets {{code|*3}} as {{code|2.71828*3}}.

==== Simple statistics ====
Suppose that {{code|X}} is an array of numbers. Then {{code|(+/X)÷⍴X}} gives its average. Reading ''right-to-left'', {{code|⍴X}} gives the number of elements in X, and since {{code|÷}} is a dyadic operator, the term to its left is required as well. It is surrounded by parentheses since otherwise X would be taken (so that the summation would be of {{code|X÷⍴X}}—each element of X divided by the number of elements in X), and {{code|+/X}} gives the sum of the elements of X. Building on this, the following expression computes [[standard deviation]]: {{sxhl|2=apl|((+/((X - (+/X)÷⍴X)*2))÷⍴X)*0.5}}

Naturally, one would define this expression as a function for repeated use rather than rewriting it each time. Further, since assignment is an operator, it can appear within an expression, so the following would place suitable values into T, AV and SD: {{sxhl|2=apl|SD←((+/((X - AV←(T←+/X)÷⍴X)*2))÷⍴X)*0.5}}

==== ''Pick 6'' lottery numbers ====
This following immediate-mode expression generates a typical set of ''Pick 6'' [[lottery]] numbers: six [[pseudo-random]] [[integer]]s ranging from 1 to 40, ''guaranteed non-repeating'', and displays them sorted in ascending order:

<syntaxhighlight lang="apl">
x[⍋x←6?40]
</syntaxhighlight>

The above does a lot, concisely, although it may seem complex to a new [[wiktionary:APLer|APLer]]. It combines the following APL ''functions'' (also called ''primitives''<ref>{{cite web|last1=MicroAPL|title=APL Primitives |url=http://www.microapl.co.uk/apl_help/ch_020_020.htm |website=www.microapl.co.uk |publisher=MicroAPL |access-date=January 11, 2015}}</ref> and ''glyphs''<ref>{{cite web |title=APL Font – Extra APL Glyphs |website=wiki.nars2000.org |url=http://wiki.nars2000.org/index.php/APL_Font |publisher=NARS2000 |access-date=January 11, 2015}}</ref>):
* The first to be executed (APL executes from rightmost to leftmost) is dyadic function <code>?</code> (named <code>deal</code> when dyadic) that returns a [[array data structure|vector]] consisting of a select number (left argument: 6 in this case) of random integers ranging from 1 to a specified maximum (right argument: 40 in this case), which, if said maximum ≥ vector length, is guaranteed to be non-repeating; thus, generate/create 6 random integers ranging from 1 to 40.<ref>{{cite web |last1=Fox |first1=Ralph L. |title=Systematically Random Numbers |publisher=SIGAPL |url=http://www.sigapl.org/article1.php |website=www.sigapl.org |access-date=January 11, 2015}}</ref>
* This vector is then ''assigned'' (<code>←</code>) to the variable <code>x</code>, because it is needed later.
* This vector is then ''sorted'' in ascending order by a monadic <code>⍋</code> function, which has as its right argument everything to the right of it up to the next unbalanced ''close-bracket'' or close-parenthesis. The result of <code>⍋</code> is the indices that will put its argument into ascending order.
* Then the output of <code>⍋</code> is used to index the variable <code>x</code>, which we saved earlier for this purpose, thereby selecting its items in ''ascending'' sequence.

Since there is no function to the left of the left-most x to tell APL what to do with the result, it simply outputs it to the display (on a single line, separated by spaces) without needing any explicit instruction to do that.

<code>?</code> also has a monadic equivalent called <code>roll</code>, which simply returns one random integer between 1 and its sole operand [to the right of it], inclusive. Thus, a [[role-playing game]] program might use the expression <code>?20</code> to roll a twenty-sided die.

==== Prime numbers ====
The following expression finds all [[prime number]]s from 1 to R. In both time and space, the calculation complexity is <math>O(R^2)\,\!</math> (in [[Big O notation]]).

<syntaxhighlight lang="apl">
(~R∊R∘.×R)/R←1↓⍳R
</syntaxhighlight>

Executed from right to left, this means:
* ''[[Iota]]'' <code>⍳</code> creates a vector containing [[integer]]s from <code>1</code> to <code>R</code> (if <code>R= 6</code> at the start of the program, <code>⍳R</code> is <code>1 2 3 4 5 6</code>)
* ''Drop'' first element of this vector (<code>↓</code> function), i.e., <code>1</code>. So <code>1↓⍳R</code> is <code>2 3 4 5 6</code>
* ''Set'' <code>R</code> to the new vector (<code>←</code>, ''assignment'' primitive), i.e., <code>2 3 4 5 6</code>
* The <code>/</code> ''replicate'' operator is dyadic (binary) and the interpreter first evaluates its left argument (fully in parentheses):
* Generate ''[[outer product]]'' of <code>R</code> multiplied by <code>R</code>, i.e., a matrix that is the ''[[multiplication table]]'' of R by R (<code>°.×</code> operator), i.e.,

{| class="wikitable" style="text-align:right;"
|-
| 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
|}
* Build a vector the same length as <code>R</code> with <code>1</code> in each place where the corresponding number in <code>R</code> is in the outer product matrix (<code>∈</code>, ''set inclusion'' or ''element of'' or ''[[Epsilon]]'' operator), i.e., <code>0 0 1 0 1</code>
* Logically negate (''not'') values in the vector (change zeros to ones and ones to zeros) (<code>∼</code>, logical ''not'' or ''[[Tilde]]'' operator), i.e., <code>1 1 0 1 0</code>
* Select the items in <code>R</code> for which the corresponding element is <code>1</code> (<code>/</code> ''replicate'' operator), i.e., <code>2 3 5</code>
(This assumes the APL origin is 1, i.e., indices start with 1. APL can be set to use 0 as the origin, so that <code>ι6</code> is <code>0 1 2 3 4 5</code>, which is convenient for some calculations.)

==== Sorting ====
The following expression [[sorting|sorts]] a word list stored in matrix X according to word length:

<syntaxhighlight lang="apl">
X[⍋X+.≠' ';]
</syntaxhighlight>

==== Game of Life ====
The following function "life", written in Dyalog APL,<ref>{{cite AV media |authorlink=John M. Scholes |last1=Scholes |first1=John |date=January 26, 2009 |title=Conway's Game of Life in APL |medium=video |url=http://www.youtube.com/watch?v=a9xAKttWgP4 |location= |publisher=[[YouTube]]|access-date=November 20, 2021}}</ref><ref>Further technical details in [https://aplwiki.com/wiki/Conway%27s_Game_of_Life APL Wiki's article "Conway's Game of Life"]. Retrieved November 20, 2021.</ref> takes a Boolean matrix and calculates the new generation according to [[Conway's Game of Life]]. It demonstrates the power of APL to implement a complex algorithm in very little code, but understanding it requires some advanced knowledge of APL (as the same program would in many languages).

<syntaxhighlight lang="apl">
life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}
</syntaxhighlight>

==== HTML tags removal ====
In the following example, also Dyalog, the first line assigns some HTML code to a variable <code>txt</code> and then uses an APL expression to remove all the HTML tags:

<syntaxhighlight lang="apl">
      txt←'<html><body><p>This is <em>emphasized</em> text.</p></body></html>'
      {⍵ /⍨ ~{⍵∨≠\⍵}⍵∊'<>'} txt
This is emphasized text.
</syntaxhighlight>