Defined function (traditional): Difference between revisions

From APL Wiki
Jump to navigation Jump to search
m (Text replacement - "<source" to "<syntaxhighlight")
Line 1: Line 1:
:''This page is about the function form typically written with the Del (<source lang=apl inline>∇</source>) character. See [[Function styles]] for an overview of all forms; in particular [[dfn]]s are considered a type of defined function in [[Dyalog APL]] and [[GNU APL]].''
:''This page is about the function form typically written with the Del (<syntaxhighlight lang=apl inline>∇</source>) character. See [[Function styles]] for an overview of all forms; in particular [[dfn]]s are considered a type of defined function in [[Dyalog APL]] and [[GNU APL]].''


A '''user-defined function''' (or '''tradfn''', pronounced "trad fun", for "traditional function", in [[Dyalog APL]]) is a function defined using a header that includes the function's name. Introduced in [[APL\360]], function definition was universally supported by APL dialects for much of the language's [[history]], and is still commonly used in mainstream APLs. Since the 1990s other ways to [[Function styles|describe functions]] have appeared, with [[J]] and [[K]] rejecting function definition in favor of [[anonymous function]] description.
A '''user-defined function''' (or '''tradfn''', pronounced "trad fun", for "traditional function", in [[Dyalog APL]]) is a function defined using a header that includes the function's name. Introduced in [[APL\360]], function definition was universally supported by APL dialects for much of the language's [[history]], and is still commonly used in mainstream APLs. Since the 1990s other ways to [[Function styles|describe functions]] have appeared, with [[J]] and [[K]] rejecting function definition in favor of [[anonymous function]] description.


{{Anchor|Representations}}The canonical representation form is equivalent to what the user would type into the [[line editor]] to define the function.<ref>[[Dyalog Ltd.]] Programming Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/cr.htm Canonical Representation].</ref> An alternative representation consists of the entire [[session]] log transcript, including [[Del]]s (<source lang=apl inline>∇</source>) and line numbers, after having such a definition has been made.<ref>[[Dyalog Ltd.]] Language Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/vr.htm Vector Representation].</ref> However, it should be noted that the <source lang=apl inline>∇</source>s are not part of the definition. Indeed, if using the [[Fix Definition]] (<source lang=apl inline>⎕FX</source>) [[system function]] to define the function, Dels need not (or must not, depending on implementation) be included.
{{Anchor|Representations}}The canonical representation form is equivalent to what the user would type into the [[line editor]] to define the function.<ref>[[Dyalog Ltd.]] Programming Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/cr.htm Canonical Representation].</ref> An alternative representation consists of the entire [[session]] log transcript, including [[Del]]s (<syntaxhighlight lang=apl inline>∇</source>) and line numbers, after having such a definition has been made.<ref>[[Dyalog Ltd.]] Language Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/vr.htm Vector Representation].</ref> However, it should be noted that the <syntaxhighlight lang=apl inline>∇</source>s are not part of the definition. Indeed, if using the [[Fix Definition]] (<syntaxhighlight lang=apl inline>⎕FX</source>) [[system function]] to define the function, Dels need not (or must not, depending on implementation) be included.


Beginning in the 2010s [[Dyalog]]-based APL dialects including [[ngn/apl]], [[dzaima/APL]], and [[APL\iv]] have removed function definition in favor of [[dfn]]s. Wikipedia has a comparison of [[Wikipedia:Direct_function#Dfns_versus_tradfns|dfns versus tradfns]].
Beginning in the 2010s [[Dyalog]]-based APL dialects including [[ngn/apl]], [[dzaima/APL]], and [[APL\iv]] have removed function definition in favor of [[dfn]]s. Wikipedia has a comparison of [[Wikipedia:Direct_function#Dfns_versus_tradfns|dfns versus tradfns]].
Line 12: Line 12:
=== Basics ===
=== Basics ===
A simple [[dyadic function]]:
A simple [[dyadic function]]:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ r←l Tradfn r
       ∇ r←l Tradfn r
         ⍝ ...do something
         ⍝ ...do something
Line 21: Line 21:
=== Semi-colons ===
=== Semi-colons ===
Assignments are global by default. To keep a name local, it must be mentioned in the header, separated from the rest of the header by a semi-colon:
Assignments are global by default. To keep a name local, it must be mentioned in the header, separated from the rest of the header by a semi-colon:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ r←l Tradfn r;intermediate
       ∇ r←l Tradfn r;intermediate
         intermediate←l r
         intermediate←l r
Line 31: Line 31:
=== Braces ===
=== Braces ===
An [[ambivalent function]] with an optional left argument, a conditional [[control structure]], one local variable, and a [[#Shyness|shy]] result:
An [[ambivalent function]] with an optional left argument, a conditional [[control structure]], one local variable, and a [[#Shyness|shy]] result:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ {res}←{left} AddMult2 right;local
       ∇ {res}←{left} AddMult2 right;local
         :If 0=⎕NC'left'    ⍝ if variable "left" is not defined already
         :If 0=⎕NC'left'    ⍝ if variable "left" is not defined already
Line 50: Line 50:
=== Brackets ===
=== Brackets ===
[[GNU APL]] allows functions and operators to accept an [[function axis|axis]] argument:<ref>[[GNU APL community]]. GNU APL Info Manual. [https://www.gnu.org/software/apl/apl.html#Section-3_002e2 Axis argument in defined functions].</ref>
[[GNU APL]] allows functions and operators to accept an [[function axis|axis]] argument:<ref>[[GNU APL community]]. GNU APL Info Manual. [https://www.gnu.org/software/apl/apl.html#Section-3_002e2 Axis argument in defined functions].</ref>
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ Z←Average[X] B
       ∇ Z←Average[X] B
         Z←(+/[X]B) ÷ (⍴B)[X]
         Z←(+/[X]B) ÷ (⍴B)[X]
Line 62: Line 62:
=== Operators ===
=== Operators ===
A [[monadic operator]] and a [[dyadic operator]], both deriving [[monadic function]]s:
A [[monadic operator]] and a [[dyadic operator]], both deriving [[monadic function]]s:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ res←(Function SELF) right
       ∇ res←(Function SELF) right
         res←right Function right
         res←right Function right
Line 77: Line 77:
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]], [[APLX]]}}
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]], [[APLX]]}}
A monadic operator and a dyadic operator, both deriving [[dyadic function]]s:
A monadic operator and a dyadic operator, both deriving [[dyadic function]]s:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ res←left (Function SWAP) right
       ∇ res←left (Function SWAP) right
         res←right Function left
         res←right Function left
Line 105: Line 105:


==== Dynamic localisation ====
==== Dynamic localisation ====
Names can be localised dynamically, while a tradfn is running, using the [[Shadow Name]] (<source lang=apl inline>⎕SHADOW</source>) [[system function]].<ref>[[Dyalog Ltd.]] Language Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/shadow.htm Shadow Name].</ref>
Names can be localised dynamically, while a tradfn is running, using the [[Shadow Name]] (<syntaxhighlight lang=apl inline>⎕SHADOW</source>) [[system function]].<ref>[[Dyalog Ltd.]] Language Reference Guide. [https://help.dyalog.com/latest/#Language/System%20Functions/shadow.htm Shadow Name].</ref>
<source lang=apl>
<syntaxhighlight lang=apl>
       name←1 2 3
       name←1 2 3
       ∇ res←Dummy
       ∇ res←Dummy
Line 121: Line 121:
==== Locals lines ====
==== Locals lines ====
Additional local names can also be declared on separate lines following the header line:<ref>[[Dyalog Ltd.]] Programming Reference Guide.  [https://help.dyalog.com/latest/#Language/Defined%20Functions%20and%20Operators/TradFns/Locals%20Lines.htm Locals Lines].</ref>
Additional local names can also be declared on separate lines following the header line:<ref>[[Dyalog Ltd.]] Programming Reference Guide.  [https://help.dyalog.com/latest/#Language/Defined%20Functions%20and%20Operators/TradFns/Locals%20Lines.htm Locals Lines].</ref>
<source lang=apl>
<syntaxhighlight lang=apl>
       name←1 2 3
       name←1 2 3
       ∇ res←Dummy
       ∇ res←Dummy
Line 135: Line 135:


==== Explicit ambivalence ====
==== Explicit ambivalence ====
The the header syntax can explicitly specify that a function is [[ambivalent]] by enclosing the left argument name in curly braces (for example <source lang=apl inline>result←{left} Function right</source>). Others dialects treat all functions that declare a left argument name as ambivalent and leave it up to the programmer to check for the presence of a value.
The the header syntax can explicitly specify that a function is [[ambivalent]] by enclosing the left argument name in curly braces (for example <syntaxhighlight lang=apl inline>result←{left} Function right</source>). Others dialects treat all functions that declare a left argument name as ambivalent and leave it up to the programmer to check for the presence of a value.


==== Function results ====
==== Function results ====
A tradfn can return a function value as result. The returned function will replace the function and its arguments (if any) in the calling expression:
A tradfn can return a function value as result. The returned function will replace the function and its arguments (if any) in the calling expression:
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ Fn←Apply name       
       ∇ Fn←Apply name       
         :If name≡'plus'     
         :If name≡'plus'     
Line 154: Line 154:


==== Shyness ====
==== Shyness ====
By default, functions in APL will print their result to the session log even without using <source lang=apl inline>⎕←</source> unless their results are shy. Shy results are declared by putting curly braces around the result name (for example <source lang=apl inline>{result}←left Function right</source>). Assignment (<source lang=apl inline>name←array</source>) exhibits the same behaviour as a shy function in that, by default, no result is printed when the function terminates, but attempting to use the result still succeeds.
By default, functions in APL will print their result to the session log even without using <syntaxhighlight lang=apl inline>⎕←</source> unless their results are shy. Shy results are declared by putting curly braces around the result name (for example <syntaxhighlight lang=apl inline>{result}←left Function right</source>). Assignment (<syntaxhighlight lang=apl inline>name←array</source>) exhibits the same behaviour as a shy function in that, by default, no result is printed when the function terminates, but attempting to use the result still succeeds.


==== Namelists ====
==== Namelists ====
The right argument and the result can be a name list instead of single name. The interpreter will unpack the right argument when the function is called, and collect the result when the function returns.<ref>[[Dyalog Ltd.]] Programming Reference Guide.  [https://help.dyalog.com/latest/#Language/Defined%20Functions%20and%20Operators/TradFns/Namelists.htm Namelists].</ref>
The right argument and the result can be a name list instead of single name. The interpreter will unpack the right argument when the function is called, and collect the result when the function returns.<ref>[[Dyalog Ltd.]] Programming Reference Guide.  [https://help.dyalog.com/latest/#Language/Defined%20Functions%20and%20Operators/TradFns/Namelists.htm Namelists].</ref>
<source lang=apl>
<syntaxhighlight lang=apl>
       ∇ (c b a)←Rev(a b c)
       ∇ (c b a)←Rev(a b c)
       ∇
       ∇

Revision as of 21:29, 10 September 2022

This page is about the function form typically written with the Del (<syntaxhighlight lang=apl inline>∇</source>) character. See Function styles for an overview of all forms; in particular dfns are considered a type of defined function in Dyalog APL and GNU APL.

A user-defined function (or tradfn, pronounced "trad fun", for "traditional function", in Dyalog APL) is a function defined using a header that includes the function's name. Introduced in APL\360, function definition was universally supported by APL dialects for much of the language's history, and is still commonly used in mainstream APLs. Since the 1990s other ways to describe functions have appeared, with J and K rejecting function definition in favor of anonymous function description.

The canonical representation form is equivalent to what the user would type into the line editor to define the function.[1] An alternative representation consists of the entire session log transcript, including Dels (<syntaxhighlight lang=apl inline>∇</source>) and line numbers, after having such a definition has been made.[2] However, it should be noted that the <syntaxhighlight lang=apl inline>∇</source>s are not part of the definition. Indeed, if using the Fix Definition (<syntaxhighlight lang=apl inline>⎕FX</source>) system function to define the function, Dels need not (or must not, depending on implementation) be included.

Beginning in the 2010s Dyalog-based APL dialects including ngn/apl, dzaima/APL, and APL\iv have removed function definition in favor of dfns. Wikipedia has a comparison of dfns versus tradfns.

In many dialects the function header syntax of defined functions is adapted to allow user-defined operators as well. A tradfn operator can also be called a tradop (pronounced "trad op"), parallel to how a "dfn" operator can be called a dop.

Examples

Basics

A simple dyadic function: <syntaxhighlight lang=apl>

     ∇ r←l Tradfn r
       ⍝ ...do something
       r←l r
     ∇

</source>

Works in: Dyalog APL, APL2, GNU APL, NARS2000, APLX, and every older APL from APL\360

Semi-colons

Assignments are global by default. To keep a name local, it must be mentioned in the header, separated from the rest of the header by a semi-colon: <syntaxhighlight lang=apl>

     ∇ r←l Tradfn r;intermediate
       intermediate←l r
       r←intermediate intermediate
     ∇

</source>

Works in: Dyalog APL, APL2, GNU APL, NARS2000, APLX, and every older APL from APL\360

Braces

An ambivalent function with an optional left argument, a conditional control structure, one local variable, and a shy result: <syntaxhighlight lang=apl>

     ∇ {res}←{left} AddMult2 right;local
       :If 0=⎕NC'left'     ⍝ if variable "left" is not defined already
           left←0
       :EndIf
       local←left+right
       res←2×local
     ∇
     AddMult2 3     ⍝ result is "shy"
     ⎕←AddMult2 3   ⍝ coerce display of result

6

     1 AddMult2 3      ⍝ result is "shy"
     10×1 AddMult2 3   ⍝ use result anyway

80 </source>

Works in: Dyalog APL

Brackets

GNU APL allows functions and operators to accept an axis argument:[3] <syntaxhighlight lang=apl>

     ∇ Z←Average[X] B
       Z←(+/[X]B) ÷ (⍴B)[X]
     ∇
     Average[1] 5 5⍴⍳25

11 12 13 14 15

     Average[2] 5 5⍴⍳25

3 8 13 18 23 </source>

Works in: GNU APL

Operators

A monadic operator and a dyadic operator, both deriving monadic functions: <syntaxhighlight lang=apl>

     ∇ res←(Function SELF) right
       res←right Function right
     ∇
     ×SELF 1 2 3 4 5

1 4 9 16 25

     ∇ res←(FunctionF HOOK FunctionG) right
       res←right FunctionF FunctionG right
     ∇
     ÷HOOK|2 0 ¯7

1 1 ¯1 </source>

A monadic operator and a dyadic operator, both deriving dyadic functions: <syntaxhighlight lang=apl>

     ∇ res←left (Function SWAP) right
       res←right Function left
     ∇
     3 2 -SWAP 10

7 8

     ∇ res←left (FunctionF OVER FunctionG) right
       res←(FunctionG left) FunctionF (FunctionG right)
     ∇
     2 ¯7 2+OVER|¯3 1 4

5 8 6 </source>

Properties

Tradfns allow both functional and procedural programming, and are essential for object-oriented programming. They support a full set of keywords for flow control and object declarations.

One of the most noticeable differences from dfns is that tradfns must declare their locals, because assignments are global by default. The declaration is done in a header line which also determines the function's name and calling syntax. Dyalog APL adds a handful of extensions this (see below).

Tradfns cannot be nested but can contain dfns. A tradfn can dynamically create another tradfn by "fixing" its source, and if the function thus created has a name which has been localised, the inner function will only exist the scope of the outer function. Nested functions are less necessary due to tradfns using dynamic scoping as opposed to the lexical scoping of dfns. In other words, a tradfn can "see" locals of its caller.

A tradfn can be niladic which causes it to behave syntactically like an array. However, every time its name is referenced, it will run to create a result (if any). Such methods are often used to return a cache or as an entry point for the user.

Dyalog APL extensions

Dyalog APL's tradfns are enhanced in various ways compared to most other dialects.[4]

Dynamic localisation

Names can be localised dynamically, while a tradfn is running, using the Shadow Name (<syntaxhighlight lang=apl inline>⎕SHADOW</source>) system function.[5] <syntaxhighlight lang=apl>

     name←1 2 3
     ∇ res←Dummy
       ⎕SHADOW'name'
       name←42
       res←name
     ∇                      
     Dummy

42

     name

1 2 3

</source>

Works in: Dyalog APL

Locals lines

Additional local names can also be declared on separate lines following the header line:[6] <syntaxhighlight lang=apl>

     name←1 2 3
     ∇ res←Dummy
       ;name
       name←42
       res←name
     ∇                      
     Dummy

42

     name

1 2 3

</source>

Works in: Dyalog APL

Explicit ambivalence

The the header syntax can explicitly specify that a function is ambivalent by enclosing the left argument name in curly braces (for example <syntaxhighlight lang=apl inline>result←{left} Function right</source>). Others dialects treat all functions that declare a left argument name as ambivalent and leave it up to the programmer to check for the presence of a value.

Function results

A tradfn can return a function value as result. The returned function will replace the function and its arguments (if any) in the calling expression: <syntaxhighlight lang=apl>

     ∇ Fn←Apply name       
       :If name≡'plus'     
           Fn←+            
       :ElseIf name≡'times'
           Fn←×            
       :EndIf              
     ∇                      
     3(Apply'plus')4

7

     3(Apply'times')4

12

</source>

Works in: Dyalog APL

Shyness

By default, functions in APL will print their result to the session log even without using <syntaxhighlight lang=apl inline>⎕←</source> unless their results are shy. Shy results are declared by putting curly braces around the result name (for example <syntaxhighlight lang=apl inline>{result}←left Function right</source>). Assignment (<syntaxhighlight lang=apl inline>name←array</source>) exhibits the same behaviour as a shy function in that, by default, no result is printed when the function terminates, but attempting to use the result still succeeds.

Namelists

The right argument and the result can be a name list instead of single name. The interpreter will unpack the right argument when the function is called, and collect the result when the function returns.[7] <syntaxhighlight lang=apl>

     ∇ (c b a)←Rev(a b c)
     ∇
     Rev 1 2 3

3 2 1

</source>

Works in: Dyalog APL

A+ differences

A+ uses a reworked style of function and operator definition than maintains the principle of a header that matches the way the function will be used, but differs in many details:

  • The result name is not included in the header; instead, the result of the last executed statement is returned (and so functions that do not return a result cannot be defined).
  • The header is separated from the body with a colon, and the body of a multi-line function is enclosed in curly braces.
  • Functions have lexical scope. Variables assigned are local by default, and can be made global by enclosing their names in parentheses when assigning.

External links

Tutorials

Documentation

References

  1. Dyalog Ltd. Programming Reference Guide. Canonical Representation.
  2. Dyalog Ltd. Language Reference Guide. Vector Representation.
  3. GNU APL community. GNU APL Info Manual. Axis argument in defined functions.
  4. Dyalog Ltd. Programming Reference Guide. Model Syntax.
  5. Dyalog Ltd. Language Reference Guide. Shadow Name.
  6. Dyalog Ltd. Programming Reference Guide. Locals Lines.
  7. Dyalog Ltd. Programming Reference Guide. Namelists.


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