APL syntax: Difference between revisions

From APL Wiki
Jump to navigation Jump to search
Miraheze>Adám Brudzewsky
No edit summary
m (Text replacement - "<source" to "<syntaxhighlight")
 
(14 intermediate revisions by 6 users not shown)
Line 1: Line 1:
APL's '''[[wikipedia:Syntax (programming languages)|syntax]]''' refers to the way programs are written—the arrangement of functions and arrays, along with other values, keywords, and punctuation—in contrast to its semantics, that is, the meaning of the actual operations performed. In part because of APL's [[Comparison with traditional mathematics|close relationship]] with mathematical notation, its syntax can be very different from typical programming languages. Distinctive features of APL include its use of infix functions, evaluated [[Evaluation order|right to left]] with no relative precedence ordering, and its division of [[array]]s, [[function]]s, and [[operator]]s into different syntactic as well as semantic classes.
== Overview ==
APL's core syntactic principles are:
APL's core syntactic principles are:
* [[Array model|Arrays]] as first class citizens
* [[Array]]s as first class citizens
* Functions take arrays as argument(s) and produce arrays as result
* [[Function]]s act on arrays and have long right scope ("right to left")
* Functions have long right scope
* [[Operator]]s act on functions or arrays and have long left scope ("left to right")
* Operators take functions and/or arrays as operand(s) and produce derived functions
A typical APL statement consists of an arrangement of the three types above, parentheses for grouping, and possibly assignment. While such individual statements may be enough for simple programming in a [[session]], larger programs are constructed by defining functions, with [[control structure]]s used to organize APL statements.
* Operators have long left scope
 
== Syntactic elements ==
In most APLs, values in the language can have one of the following classes:
* [[Array]]s, the fundamental type for program data
* [[Function]]s, which can be called on arrays either [[monadic]]ally or [[dyadic]]ally
* [[Monadic operator]]s, which take a single function or array [[operand]] and produce a [[derived function]]
* [[Dyadic operator]]s, which take two operands and produce a derived function
* [[Niladic function]]s, which are evaluated immediately to become one of the above values
* In some APLs, [[hyperator]]s continue the array-function-operator hierarchy.
Each of these values can usually be stored in a variable, either by [[assignment]] or [[function definition]]. Values of these types can also be written directly in many cases, with [[string]]s, [[numeric literal]]s, or [[array notation]], as predefined [[primitive function]]s and [[primitive operator|operators]], or as inline [[dfn]]s. There are some anomalies which do not fit easily into this system, such as [[Outer Product]], which is written with two [[glyph]]s, and [[function-operator overloading]].
 
Additionally, there are some syntactic elements that cannot be used as values:
* The assignment arrow <syntaxhighlight lang=apl inline>←</syntaxhighlight>
* Square brackets <syntaxhighlight lang=apl inline>[]</syntaxhighlight> used for [[bracket indexing]] and [[function axis]] specification
* Parentheses <syntaxhighlight lang=apl inline>()</syntaxhighlight> for grouping
* The Diamond <syntaxhighlight lang=apl inline>⋄</syntaxhighlight> and newline characters used as a [[statement separator]]
* The [[Del]] character <syntaxhighlight lang=apl inline>∇</syntaxhighlight> used for [[tradfn]]s, or curly braces for [[dfn]]s
* [[Keyword]]s for [[control structure]]s
* The [[branch]] arrow <syntaxhighlight lang=apl inline>→</syntaxhighlight>
 
The second group, consisting of fixed syntax written with particular tokens, is common to many programming languages (in fact, APL tends to have a simpler fixed syntax than many contemporary languages). However, the first group is unusual because it means that a variable's syntactic properties are determined by the variable's value and not just by how it's written. This property makes it impossible to parse an APL statement with variables in general: for example, the statement <syntaxhighlight lang=apl inline>a b c</syntaxhighlight> could be a function application, two function applications, a function modified by an operator, and so on.


== Example array definitions ==
== Example array definitions ==
<pre class="language-apl">
<syntaxhighlight lang=apl>
       simplenumvec←1 2 3 4 ⍝ A simple numeric vector
       simplenumvec←1 2 3 4 ⍝ A simple numeric vector
       simplecharvec←'ABCD' ⍝ A simple character vector
       simplecharvec←'ABCD' ⍝ A simple character vector
</pre>
</syntaxhighlight>


== Example function definition ==
== Example function definition ==
<pre class="language-apl">
<syntaxhighlight lang=apl>
     ∇  r←l Tradfn r               
     ∇  r←l Tradfn r               
[1]    ⍝ An infix (dyadic) tradfn
[1]    ⍝ An infix (dyadic) tradfn
[2]    r←l r                     
[2]    r←l r                     
     ∇   
     ∇   
</pre>
</syntaxhighlight>
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]]}}
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]]}}


== Example operator definition ==
== Example operator definition ==
<pre class="language-apl">
<syntaxhighlight lang=apl>
     ∇ r←larg(Main OVER PreProc)rarg                                                 
     ∇ r←larg(Main OVER PreProc)rarg                                                 
[1]    r←(PreProc larg)Main(PreProc rarg)                                             
[1]    r←(PreProc larg)Main(PreProc rarg)                                             
     ∇   
     ∇   
</pre>
</syntaxhighlight>
== Example function application ==
== Example function application ==
<pre class="language-apl">
<syntaxhighlight lang=apl>
</pre>
      ÷3        ⍝ Prefix primitive function
0.3333333333
      1+2        ⍝ Infix primitive function
3
      +/1 2 3 4  ⍝ Prefix primitive derived function
10
      2+/1 2 3 4 ⍝ Infix primitive derived function
3 5 7
</syntaxhighlight>


== Scoping rules ==
== Scoping rules ==
Line 37: Line 68:
=== Operators ===
=== Operators ===


{{APL programming language}}
== External links ==
 
* [[wikipedia:APL syntax and symbols|APL syntax and symbols]]
 
{{APL syntax}}[[Category:APL syntax| ]]

Latest revision as of 22:16, 10 September 2022

APL's syntax refers to the way programs are written—the arrangement of functions and arrays, along with other values, keywords, and punctuation—in contrast to its semantics, that is, the meaning of the actual operations performed. In part because of APL's close relationship with mathematical notation, its syntax can be very different from typical programming languages. Distinctive features of APL include its use of infix functions, evaluated right to left with no relative precedence ordering, and its division of arrays, functions, and operators into different syntactic as well as semantic classes.

Overview

APL's core syntactic principles are:

  • Arrays as first class citizens
  • Functions act on arrays and have long right scope ("right to left")
  • Operators act on functions or arrays and have long left scope ("left to right")

A typical APL statement consists of an arrangement of the three types above, parentheses for grouping, and possibly assignment. While such individual statements may be enough for simple programming in a session, larger programs are constructed by defining functions, with control structures used to organize APL statements.

Syntactic elements

In most APLs, values in the language can have one of the following classes:

Each of these values can usually be stored in a variable, either by assignment or function definition. Values of these types can also be written directly in many cases, with strings, numeric literals, or array notation, as predefined primitive functions and operators, or as inline dfns. There are some anomalies which do not fit easily into this system, such as Outer Product, which is written with two glyphs, and function-operator overloading.

Additionally, there are some syntactic elements that cannot be used as values:

The second group, consisting of fixed syntax written with particular tokens, is common to many programming languages (in fact, APL tends to have a simpler fixed syntax than many contemporary languages). However, the first group is unusual because it means that a variable's syntactic properties are determined by the variable's value and not just by how it's written. This property makes it impossible to parse an APL statement with variables in general: for example, the statement a b c could be a function application, two function applications, a function modified by an operator, and so on.

Example array definitions

      simplenumvec←1 2 3 4 ⍝ A simple numeric vector
      simplecharvec←'ABCD' ⍝ A simple character vector

Example function definition

    ∇  r←l Tradfn r              
[1]    ⍝ An infix (dyadic) tradfn
[2]    r←l r                     
    ∇

Example operator definition

     ∇ r←larg(Main OVER PreProc)rarg                                                 
[1]    r←(PreProc larg)Main(PreProc rarg)                                            
     ∇

Example function application

      ÷3         ⍝ Prefix primitive function
0.3333333333
      1+2        ⍝ Infix primitive function
3
      +/1 2 3 4  ⍝ Prefix primitive derived function
10
      2+/1 2 3 4 ⍝ Infix primitive derived function
3 5 7

Scoping rules

Functions

Operators

External links


APL syntax [edit]
General Comparison with traditional mathematicsPrecedenceTacit programming (Train, Hook, Split composition)
Array Numeric literalStringStrand notationObject literalArray notation (design considerations)
Function ArgumentFunction valenceDerived functionDerived operatorNiladic functionMonadic functionDyadic functionAmbivalent functionDefined function (traditional)DfnFunction train
Operator OperandOperator valenceTradopDopDerived operator
Assignment MultipleIndexedSelectiveModified
Other Function axisBracket indexingBranchStatement separatorQuad nameSystem commandUser commandKeywordDot notationFunction-operator overloadingControl structureComment