Defined function (traditional): Difference between revisions

From APL Wiki
Jump to navigation Jump to search
No edit summary
Line 7: Line 7:
A simple [[dyadic function]]:
A simple [[dyadic function]]:
<source lang=apl>
<source lang=apl>
∇ r←l Tradfn r
      ∇ r←l Tradfn r
  ⍝ ...do something
        ⍝ ...do something
  r←l r
        r←l r
     
</source>
</source>
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]], [[APLX]], and every older APL from [[APL\360]]}}
{{Works in|[[Dyalog APL]], [[APL2]], [[GNU APL]], [[NARS2000]], [[APLX]], and every older APL from [[APL\360]]}}
Line 16: Line 16:
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>
<source 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
      left←0
            left←0
  :EndIf
        :EndIf
  local←left+right
        local←left+right
  res←2×local
        res←2×local
     
       AddMult2 3    ⍝ result is "shy"
       AddMult2 3    ⍝ result is "shy"
       ⎕←AddMult2 3  ⍝ coerce display of result
       ⎕←AddMult2 3  ⍝ coerce display of result
Line 35: Line 35:
[[GNU APL]] allows functions and operators to accept an [[function axis|axis]] argument:<ref>[https://www.gnu.org/software/apl/apl.html#Section-3_002e2 3.2 Axis argument in defined functions] – GNU APL Manual</ref>
[[GNU APL]] allows functions and operators to accept an [[function axis|axis]] argument:<ref>[https://www.gnu.org/software/apl/apl.html#Section-3_002e2 3.2 Axis argument in defined functions] – GNU APL Manual</ref>
<source lang=apl>
<source lang=apl>
∇ Z←Average[X] B
      ∇ Z←Average[X] B
  Z←(+/[X]B) ÷ (⍴B)[X]
        Z←(+/[X]B) ÷ (⍴B)[X]
     
       Average[1] 5 5⍴⍳25
       Average[1] 5 5⍴⍳25
11 12 13 14 15
11 12 13 14 15
Line 47: Line 47:
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>
<source lang=apl>
∇ res←(Function SELF) right
      ∇ res←(Function SELF) right
  res←right Function right
        res←right Function right
     
       ×SELF 1 2 3 4 5
       ×SELF 1 2 3 4 5
1 4 9 16 25
1 4 9 16 25


∇ res←(FunctionF HOOK FunctionG) right
      ∇ res←(FunctionF HOOK FunctionG) right
  res←right FunctionF FunctionG right
        res←right FunctionF FunctionG right
     
       ÷HOOK|2 0 ¯7
       ÷HOOK|2 0 ¯7
1 1 ¯1
1 1 ¯1
Line 62: Line 62:
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>
<source lang=apl>
∇ res←left (Function SWAP) right
      ∇ res←left (Function SWAP) right
  res←right Function left
        res←right Function left
     
       3 2 -SWAP 10
       3 2 -SWAP 10
7 8
7 8


∇ res←left (FunctionF OVER FunctionG) right
      ∇ res←left (FunctionF OVER FunctionG) right
  res←(FunctionG left) FunctionF (FunctionG right)
        res←(FunctionG left) FunctionF (FunctionG right)
     
       2 ¯7 2+OVER|¯3 1 4
       2 ¯7 2+OVER|¯3 1 4
5 8 6
5 8 6
Line 94: Line 94:
<source lang=apl>
<source lang=apl>
       name←1 2 3
       name←1 2 3
∇ res←Dummy
      ∇ res←Dummy
  ⎕SHADOW'name'
        ⎕SHADOW'name'
  name←42
        name←42
  res←name
        res←name
∇                       
      ∇                       
       Dummy
       Dummy
42
42
Line 108: Line 108:
<source lang=apl>
<source lang=apl>
       name←1 2 3
       name←1 2 3
∇ res←Dummy
      ∇ res←Dummy
  ;name
        ;name
  name←42
        name←42
  res←name
        res←name
∇                       
      ∇                       
       Dummy
       Dummy
42
42
Line 123: Line 123:
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>
<source lang=apl>
    Fn←Apply name       
      ∇ Fn←Apply name       
[1]    :If name≡'plus'     
        :If name≡'plus'     
[2]        Fn←+             
            Fn←+             
[3]    :ElseIf name≡'times'
        :ElseIf name≡'times'
[4]        Fn←×             
            Fn←×             
[5]    :EndIf               
        :EndIf               
    ∇                       
      ∇                       
      3(Apply'plus')4
      3(Apply'plus')4
7
7
      3(Apply'times')4
      3(Apply'times')4
12
12
</source>{{Works in|[[Dyalog APL]]}}
</source>{{Works in|[[Dyalog APL]]}}
Line 139: Line 139:


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/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/Namelists.htm Namelists].</ref>
 
<source lang=apl>
      ∇ (c b a)←Rev(a b c)
      ∇
      Rev 1 2 3
3 2 1
</source>{{Works in|[[Dyalog APL]]}}
== A+ ==
== A+ ==
[[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:
[[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:

Revision as of 09:23, 20 July 2020

A user-defined function (or tradfn, 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. Beginning in the 2010s Dyalog-based APL dialects including ngn/apl, dzaima/APL, and APL\iv have removed function definition in favor of dfns.

In many dialects the function header syntax of defined functions is adapted to allow user-defined operators as well.

Examples

Basics

A simple dyadic function:

      ∇ r←l Tradfn r
        ⍝ ...do something
        r←l r
      ∇
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:

      ∇ {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
Works in: Dyalog APL

Brackets

GNU APL allows functions and operators to accept an axis argument:[1]

      ∇ 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
Works in: GNU APL

Operators

A monadic operator and a dyadic operator, both deriving monadic functions:

      ∇ 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

A monadic operator and a dyadic operator, both deriving dyadic functions:

      ∇ 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

Representations

The canonical representation form is equivalent to what the user would type into the line editor to define the function. An alternative representation consists of the entire session log transcript after having such a definition has been made. A tradfn operator can also be called a tradop (pronounced "trad op").

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.[2]

Names can be localised dynamically, while a tradfn is running, using the Shadow Name (⎕SHADOW) system function.[3]

      name←1 2 3
      ∇ res←Dummy
        ⎕SHADOW'name'
        name←42
        res←name
      ∇                      
      Dummy
42
      name
1 2 3
Works in: Dyalog APL

Additional local names can also be declared on separate lines following the header line:[4]

      name←1 2 3
      ∇ res←Dummy
        ;name
        name←42
        res←name
      ∇                      
      Dummy
42
      name
1 2 3
Works in: Dyalog APL

The the header syntax can explicitly specify that a function is ambivalent by enclosing the left argument name in curly braces (for example result←{left} Function right). 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.

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:

      ∇ Fn←Apply name       
        :If name≡'plus'     
            Fn←+            
        :ElseIf name≡'times'
            Fn←×            
        :EndIf              
      ∇                      
      3(Apply'plus')4
7
      3(Apply'times')4
12
Works in: Dyalog APL

A tradfn can be declared as shy, that is, it exhibits the same behaviour as an assignment, in that by default, no result is printed when the function terminates, but attempting to use the result still succeeds. This declaration is done by putting curly braces around the result name (for example {result}←left Function right).

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.[5]

      ∇ (c b a)←Rev(a b c)
      ∇
      Rev 1 2 3
3 2 1
Works in: Dyalog APL

A+

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.

Comparison to dfns

Wikipedia has a comparison of dfns versus tradfns.

External links

Tutorials

Documentation

References

  1. 3.2 Axis argument in defined functions – GNU APL Manual
  2. Dyalog Ltd. Programming Reference Guide. Model Syntax.
  3. Dyalog Ltd. Language Reference Guide. Shadow Name.
  4. Dyalog Ltd. Programming Reference Guide. Locals Lines.
  5. 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