Función directa

"Dfns" vuelve a dirigir aquí. Para la entidad política a veces conocida como la Federación Democrática del Norte de Siria, consulte Rojava .

Una función directa ( dfn , pronunciado "dee fun") es una forma alternativa de definir una función y un operador (una función de orden superior ) en el lenguaje de programación APL . Un operador directo también puede llamarse dop (pronunciado "dee op"). Fueron inventados por John Scholes en 1996. ^[1] Son una combinación única de programación de matrices , función de orden superior y programación funcional , y son un avance distintivo importante de APL de principios del siglo XXI sobre versiones anteriores.

Un dfn es una secuencia de expresiones posiblemente protegidas (o simplemente una protección) entre {y }, separadas por ⋄o nuevas líneas, donde ⍺denota el argumento izquierdo y ⍵el derecho, y ∇denota recursividad (función de autorreferencia). Por ejemplo, la función PTprueba si cada fila de ⍵es un triplete pitagórico (probando si la suma de cuadrados es igual al doble del cuadrado del máximo).

 PT ←  { ( + / ⍵ * 2 ) = 2 × ( ⌈ / ⍵ ) * 2 }  PT  3  4  5 1  x  4  5  3  3  11  6  5  13  12 17  16  8 11  12  4 17  15  8  PT  x 1  0  1  0  0  1

La función factorial como dfn:

 hecho ←  { 0 = ⍵: 1  ⋄  ⍵ × ∇  ⍵ - 1 }  hecho  5 120  hecho de ¨  ⍳ 10  ⍝ hecho aplica a cada elemento de 0 a 9 1  1  2  6  24  120  720  5040  40 320  362 880

Descripción

Las reglas para dfns se resumen en la siguiente "tarjeta de referencia": ^[2]

{⍺ function ⍵}	{⍺⍺ operator ⍵⍵}	:   Guardia
⍺  argumento de la izquierda	⍺⍺  operando izquierdo	::  guardia de error
⍵  argumento correcto	⍵⍵  operando derecho	⍺←  argumento izquierdo predeterminado
∇  autorreferencia	∇∇  autorreferencia	s←  resultado tímido

Un dfn es una secuencia de expresiones posiblemente protegidas (o simplemente una protección) entre {y }, separadas por ⋄o nuevas líneas.

expresión de guardia :  la expresión de guardia :

The expressions and/or guards are evaluated in sequence. A guard must evaluate to a 0 or 1; its associated expression is evaluated if the value is 1. A dfn terminates after the first unguarded expression which does not end in assignment, or after the first guarded expression whose guard evaluates to 1, or if there are no more expressions. The result of a dfn is that of the last evaluated expression. If that last evaluated expression ends in assignment, the result is "shy"—not automatically displayed in the session.

Names assigned in a dfn are local by default, with lexical scope.

⍺denota el argumento de la función izquierda y ⍵la derecha; ⍺⍺denota el operando izquierdo y ⍵⍵el derecho. Si ⍵⍵aparece en la definición, entonces dfn es un operador diádico ; si solo ⍺⍺ocurre pero no ⍵⍵, entonces es un operador monádico; si no ocurre nada ⍺⍺o ⍵⍵, entonces dfn es una función.

La sintaxis especial se usa para dar un valor predeterminado al argumento de la izquierda si un dfn se llama monádicamente, es decir, se llama sin un argumento de la izquierda. No se evalúa de otra manera.⍺←expression⍺←expression

∇denota recursividad o autorreferencia por la función y ∇∇denota autorreferencia por parte del operador. Tal denotación permite la recursividad anónima .

Error trapping is provided through error-guards, errnums::expression. When an error is generated, the system searches dynamically through the calling functions for an error-guard that matches the error. If one is found, the execution environment is unwound to its state immediately prior to the error-guard's execution and the associated expression of the error-guard is evaluated as the result of the dfn.

Additional descriptions, explanations, and tutorials on dfns are available in the cited articles.^{[3][4][5][6][7]}

Examples

The examples here illustrate different aspects of dfns. Additional examples are found in the cited articles.^[8][9][10]

Argumento izquierdo predeterminado

La función se suma a ( i o √ −1 ) veces .{⍺+0j1×⍵}⍺0j1⍵

 3 {⍺+0j1×⍵} 43J4 ∘.{⍺+0j1×⍵}⍨ ¯2+⍳5¯2J¯2 ¯2J¯1 ¯2 ¯2J1 ¯2J2¯1J¯2 ¯1J¯1 ¯1 ¯1J1 ¯1J2 0J¯2 0J¯1 0 0J1 0J2 1J¯2 1J¯1 1 1J1 1J2 2J¯2 2J¯1 2 2J1 2J2

The significance of this function can be seen as follows:

Complex numbers can be constructed as ordered pairs of real numbers, similar to how integers can be constructed as ordered pairs of natural numbers and rational numbers as ordered pairs of integers. For complex numbers, {⍺+0j1×⍵} plays the same role as - for integers and ÷ for rational numbers.^[11]:§8

Moreover, analogous to that monadic -⍵ ⇔ 0-⍵ (negate) and monadic ÷⍵ ⇔ 1÷⍵ (reciprocal), a monadic definition of the function is useful, effected by specifying a default value of 0 for ⍺: if j←{⍺←0 ⋄ ⍺+0j1×⍵}, then j ⍵ ⇔ 0 j ⍵ ⇔ 0+0j1×⍵.

 j←{⍺←0 ⋄ ⍺+0j1×⍵} 3 j 4 ¯5.6 7.893J4 3J¯5.6 3J7.89 j 4 ¯5.6 7.890J4 0J¯5.6 0J7.89 sin← 1∘○ cos← 2∘○ Euler← {(*j ⍵) = (cos ⍵) j (sin ⍵)} Euler (¯0.5+?10⍴0) j (¯0.5+?10⍴0)1 1 1 1 1 1 1 1 1 1

The last expression illustrates Euler's formula on ten random numbers with real and imaginary parts in the interval ${\displaystyle \left(-0.5,0.5\right)}$.

Single recursion

The ternary construction of the Cantor set starts with the interval [0,1] and at each stage removes the middle third from each remaining subinterval:

${\displaystyle {\biggl [}0,1{\biggr ]}\to }$

${\displaystyle \left[0,{\frac {1}{3}}\right]\cup \left[{\frac {2}{3}},1\right]\to }$

${\displaystyle \left[0,{\frac {1}{9}}\right]\cup \left[{\frac {2}{9}},{\frac {1}{3}}\right]\cup \left[{\frac {2}{3}},{\frac {7}{9}}\right]\cup \left[{\frac {8}{9}},1\right]\to \cdots }$

The Cantor set of order ⍵ defined as a dfn:^[11]:§2.5

 Cantor← {0=⍵:,1 ⋄ ,1 0 1 ∘.∧ ∇ ⍵-1} Cantor 01 Cantor 11 0 1 Cantor 21 0 1 0 0 0 1 0 1 Cantor 31 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1

Cantor 0 to Cantor 6 depicted as black bars:

The function sieve ⍵ computes a bit vector of length ⍵ so that bit i (for 0≤i and i<⍵) is 1 if and only if i is a prime.^[10]:§46

sieve←{ 4≥⍵:⍵⍴0 0 1 1 r←⌊0.5*⍨n←⍵ p←2 3 5 7 11 13 17 19 23 29 31 37 41 43 p←(1+(n≤×⍀p)⍳1)↑p b← 0@1 ⊃ {(m⍴⍵)>m⍴⍺↑1 ⊣ m←n⌊⍺×≢⍵}⌿ ⊖1,p {r<q←b⍳1:b⊣b[⍵]←1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ ∇ ⍵,q}p} 10 10 ⍴ sieve 1000 0 1 1 0 1 0 1 0 00 1 0 1 0 0 0 1 0 10 0 0 1 0 0 0 0 0 10 1 0 0 0 0 0 1 0 00 1 0 1 0 0 0 1 0 00 0 0 1 0 0 0 0 0 10 1 0 0 0 0 0 1 0 00 1 0 1 0 0 0 0 0 10 0 0 1 0 0 0 0 0 10 0 0 0 0 0 0 1 0 0 b←sieve 1e9 ≢b1000000000 (10*⍳10) (+⌿↑)⍤0 1 ⊢b0 4 25 168 1229 9592 78498 664579 5761455 50847534

The last sequence, the number of primes less than powers of 10, is an initial segment of OEIS: A006880. The last number, 50847534, is the number of primes less than ${\displaystyle 10^{9}}$. It is called Bertelsen's number, memorably described by MathWorld as "an erroneous name erroneously given the erroneous value of ${\displaystyle \pi (10^{9})=50847478}$".^[12]

sieve uses two different methods to mark composites with 0s, both effected using local anonymous dfns: The first uses the sieve of Eratosthenes on an initial mask of 1 and a prefix of the primes 2 3...43, using the insert operator ⌿ (right fold). (The length of the prefix obtains by comparison with the primorial function ×⍀p.) The second finds the smallest new prime q remaining in b (q←b⍳1), and sets to 0 bit q itself and bits at q times the numbers at remaining 1 bits in an initial segment of b (⍸b↑⍨⌈n÷q). This second dfn uses tail recursion.

Tail recursion

Typically, the factorial function is define recursively (as above), but it can be coded to exploit tail recursion by using an accumulator left argument:^[13]

fac←{⍺←1 ⋄ ⍵=0:⍺ ⋄ (⍺×⍵) ∇ ⍵-1}

Similarly, the determinant of a square complex matrix using Gaussian elimination can be computed with tail recursion:^[14]

det←{ ⍝ determinant of a square complex matrix ⍺←1 ⍝ product of co-factor coefficients so far 0=≢⍵:⍺ ⍝ result for 0-by-0 (i j)←(⍴⍵)⊤⊃⍒|,⍵ ⍝ row and column index of the maximal element k←⍳≢⍵ (⍺×⍵[i;j]ׯ1*i+j) ∇ ⍵[k~i;k~j] - ⍵[k~i;j] ∘.× ⍵[i;k~j]÷⍵[i;j]}

Multiple recursion

A partition of a non-negative integer ${\displaystyle n}$ is a vector ${\displaystyle v}$ of positive integers such that n = +⌿v, where the order in ${\displaystyle v}$ is not significant. For example, 2 2 and 2 1 1 are partitions of 4, and 2 1 1 and 1 2 1 and 1 1 2 are considered to be the same partition.

The partition function ${\displaystyle P(n)}$ counts the number of partitions. The function is of interest in number theory, studied by Euler, Hardy, Ramanujan, Erdős, and others. The recurrence relation

${\displaystyle P(n)=\sum _{k=1}^{n}(-1)^{k+1}[P(n-{\frac {1}{2}}k(3k-1))+P(n-{\frac {1}{2}}k(3k+1))]}$

derived from Euler's pentagonal number theorem.^[15] Written as a dfn:^[10]:§16

 pn ← {1≥⍵:0≤⍵ ⋄ -⌿+⌿∇¨rec ⍵} rec ← {⍵ - (÷∘2 (×⍤1) ¯1 1 ∘.+ 3∘×) 1+⍳⌈0.5*⍨⍵×2÷3} pn 1042 pn¨ ⍳13 ⍝ OEIS A0000411 1 2 3 5 7 11 15 22 30 42 56 77

The basis step 1≥⍵:0≤⍵ states that for 1≥⍵, the result of the function is 0≤⍵, 1 if ⍵ is 0 or 1 and 0 otherwise. The recursive step is highly multiply recursive. For example, pn 200 would result in the function being applied to each element of rec 200, which are:

 rec 200199 195 188 178 165 149 130 108 83 55 24 ¯10198 193 185 174 160 143 123 100 74 45 13 ¯22

and pn 200 requires longer than the age of the universe to compute (${\displaystyle 7.57\times 10^{47}}$ function calls to itself).^[10]:§16 The compute time can be reduced by memoization, here implemented as the direct operator (higher-order function) M:

M←{ f←⍺⍺ i←2+'⋄'⍳⍨t←2↓,⎕cr 'f' ⍎'{T←(1+⍵)⍴¯1 ⋄ ',(i↑t),'¯1≢T[⍵]:⊃T[⍵] ⋄ ⊃T[⍵]←⊂',(i↓t),'⍵}⍵'} pn M 2003.973E12 0 ⍕ pn M 200 ⍝ format to 0 decimal places 3972999029388

This value of pn M 200 agrees with that computed by Hardy and Ramanujan in 1918.^[16]

The memo operator M defines a variant of its operand function ⍺⍺ to use a cache T and then evaluates it. With the operand pn the variant is:

{T←(1+⍵)⍴¯1 ⋄ {1≥⍵:0≤⍵ ⋄ ¯1≢T[⍵]:⊃T[⍵] ⋄ ⊃T[⍵]←⊂-⌿+⌿∇¨rec ⍵}⍵}

Direct operator (dop)

Quicksort on an array ⍵ works by choosing a "pivot" at random among its major cells, then catenating the sorted major cells which strictly precede the pivot, the major cells equal to the pivot, and the sorted major cells which strictly follow the pivot, as determined by a comparison function ⍺⍺. Defined as a direct operator (dop) Q:

 Q←{1≥≢⍵:⍵ ⋄ (∇ ⍵⌿⍨0>s)⍪(⍵⌿⍨0=s)⍪∇ ⍵⌿⍨0<s←⍵ ⍺⍺ ⍵⌷⍨?≢⍵} ⍝ precedes ⍝ follows ⍝ equals 2 (×-) 8 8 (×-) 2 8 (×-) 8¯1 1 0 x← 2 19 3 8 3 6 9 4 19 7 0 10 15 14 (×-) Q x0 2 3 3 4 6 7 8 9 10 14 15 19 19

Q3 is a variant that catenates the three parts enclosed by the function ⊂ instead of the parts per se. The three parts generated at each recursive step are apparent in the structure of the final result. Applying the function derived from Q3 to the same argument multiple times gives different results because the pivots are chosen at random. In-order traversal of the results does yield the same sorted array.

 Q3←{1≥≢⍵:⍵ ⋄ (⊂∇ ⍵⌿⍨0>s)⍪(⊂⍵⌿⍨0=s)⍪⊂∇ ⍵⌿⍨0<s←⍵ ⍺⍺ ⍵⌷⍨?≢⍵} (×-) Q3 x┌────────────────────────────────────────────┬─────┬┐│┌──────────────┬─┬─────────────────────────┐│19 19││││┌──────┬───┬─┐│6│┌──────┬─┬──────────────┐││ │││││┌┬─┬─┐│3 3│4││ ││┌┬─┬─┐│9│┌┬──┬────────┐│││ │││││││0│2││ │ ││ ││││7│8││ │││10│┌──┬──┬┐││││ │││││└┴─┴─┘│ │ ││ ││└┴─┴─┘│ │││ ││14│15││││││ ││││└──────┴───┴─┘│ ││ │ │││ │└──┴──┴┘││││ ││││ │ ││ │ │└┴──┴────────┘│││ ││││ │ │└──────┴─┴──────────────┘││ │││└──────────────┴─┴─────────────────────────┘│ ││└────────────────────────────────────────────┴─────┴┘ (×-) Q3 x┌───────────────────────────┬─┬─────────────────────────────┐│┌┬─┬──────────────────────┐│7│┌────────────────────┬─────┬┐││││0│┌┬─┬─────────────────┐││ ││┌──────┬──┬────────┐│19 19││││││ │││2│┌────────────┬─┬┐│││ │││┌┬─┬─┐│10│┌──┬──┬┐││ ││││││ │││ ││┌───────┬─┬┐│6│││││ │││││8│9││ ││14│15││││ ││││││ │││ │││┌┬───┬┐│4│││ │││││ │││└┴─┴─┘│ │└──┴──┴┘││ ││││││ │││ │││││3 3│││ │││ │││││ ││└──────┴──┴────────┘│ ││││││ │││ │││└┴───┴┘│ │││ │││││ │└────────────────────┴─────┴┘││││ │││ ││└───────┴─┴┘│ │││││ │ ││││ │││ │└────────────┴─┴┘│││ │ ││││ │└┴─┴─────────────────┘││ │ ││└┴─┴──────────────────────┘│ │ │└───────────────────────────┴─┴─────────────────────────────┘

The above formulation is not new; see for example Figure 3.7 of the classic The Design and Analysis of Computer Algorithms.^[17] However, unlike the pidgin ALGOL program in Figure 3.7, Q is executable, and the partial order used in the sorting is an operand, the (×-) the examples above.^[9]

Dfns with operators and trains

Dfns, especially anonymous dfns, work well with operators and trains. The following snippet solves a "Programming Pearls" puzzle:^[18] given a dictionary of English words, here represented as the character matrix a, find all sets of anagrams.

 a {⍵[⍋⍵]}⍤1 ⊢a ({⍵[⍋⍵]}⍤1 {⊂⍵}⌸ ⊢) apats apst ┌────┬────┬────┐spat apst │pats│teas│star│teas aest │spat│sate│ │sate aest │taps│etas│ │taps apst │past│seat│ │etas aest │ │eats│ │past apst │ │tase│ │seat aest │ │east│ │eats aest │ │seta│ │tase aest └────┴────┴────┘star arsteast aestseta aest

The algorithm works by sorting the rows individually ({⍵[⍋⍵]}⍤1 ⊢a), and these sorted rows are used as keys ("signature" in the Programming Pearls description) to the key operator ⌸ to group the rows of the matrix.^[9]:§3.3 The expression on the right is a train, a syntactic form employed by APL to achieve tacit programming. Here, it is an isolated sequence of three functions such that (f g h) ⍵ ⇔ (f ⍵) g (h ⍵), whence the expression on the right is equivalent to ({⍵[⍋⍵]}⍤1 ⊢a) {⊂⍵}⌸ a.

Lexical scope

When an inner (nested) dfn refers to a name, it is sought by looking outward through enclosing dfns rather than down the call stack. This regime is said to employ lexical scope instead of APL's usual dynamic scope. The distinction becomes apparent only if a call is made to a function defined at an outer level. For the more usual inward calls, the two regimes are indistinguishable.^[19]:p.137

For example, in the following function which, the variable ty is defined both in which itself and in the inner function f1. When f1 calls outward to f2 and f2 refers to ty, it finds the outer one (with value 'lexical') rather than the one defined in f1 (with value 'dynamic'):

which←{ ty←'lexical' f1←{ty←'dynamic' ⋄ f2 ⍵} f2←{ty,⍵} f1 ⍵} which ' scope'lexical scope

Error-guard

The following function illustrates use of error guards:^[19]:p.139

plus←{ tx←'catch all' ⋄ 0::tx tx←'domain' ⋄ 11::tx tx←'length' ⋄ 5::tx ⍺+⍵} 2 plus 3 ⍝ no errors5 2 3 4 5 plus 'three' ⍝ argument lengths don't matchlength 2 3 4 5 plus 'four' ⍝ can't add charactersdomain 2 3 plus 3 4⍴5 ⍝ can't add vector to matrixcatch all

In APL, error number 5 is "length error"; error number 11 is "domain error"; and error number 0 is a "catch all" for error numbers 1 to 999.

The example shows the unwinding of the local environment before an error-guard's expression is evaluated. The local name tx is set to describe the purview of its following error-guard. When an error occurs, the environment is unwound to expose tx's statically correct value.

Dfns versus tradfns

Since direct functions are dfns, APL functions defined in the traditional manner are referred to as tradfns, pronounced "trad funs". Here, dfns and tradfns are compared by consideration of the function sieve: On the left is a dfn (as defined above); in the middle is a tradfn using control structures; on the right is a tradfn using gotos (→) and line labels.

sieve←{ 4≥⍵:⍵⍴0 0 1 1 r←⌊0.5*⍨n←⍵ p←2 3 5 7 11 13 17 19 23 29 31 37 41 43 p←(1+(n≤×⍀p)⍳1)↑p b← 0@1 ⊃ {(m⍴⍵)>m⍴⍺↑1 ⊣ m←n⌊⍺×≢⍵}⌿ ⊖1,p {r<q←b⍳1:b⊣b[⍵]←1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ ∇ ⍵,q}p }

∇ b←sieve1 n;i;m;p;q;r :If 4≥n ⋄ b←n⍴0 0 1 1 ⋄ :Return ⋄ :EndIf r←⌊0.5*⍨n p←2 3 5 7 11 13 17 19 23 29 31 37 41 43 p←(1+(n≤×⍀p)⍳1)↑p b←1 :For q :In p ⋄ b←(m⍴b)>m⍴q↑1 ⊣ m←n⌊q×≢b ⋄ :EndFor b[1]←0 :While r≥q←b⍳1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ p⍪←q ⋄ :EndWhile b[p]←1 ∇

∇ b←sieve2 n;i;m;p;q;r →L10 ⍴⍨ 4<n ⋄ b←n⍴0 0 1 1 ⋄ →0 L10: r←⌊0.5*⍨n p←2 3 5 7 11 13 17 19 23 29 31 37 41 43 p←(1+(n≤×\p)⍳1)↑p i←0 ⋄ b←1 L20: b←(m⍴b)>m⍴p[i]↑1 ⊣ m←n⌊p[i]×≢b →L20 ⍴⍨ (≢p)>i←1+i b[1]←0 L30: →L40 ⍴⍨ r<q←b⍳1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ p⍪←q ⋄ →L30 L40: b[p]←1 ∇

• A dfn can be anonymous; a tradfn must be named.
• A dfn is named by assignment (←); a tradfn is named by embedding the name in the representation of the function and applying ⎕fx (a system function) to that representation.
• A dfn is handier than a tradfn as an operand (see preceding items: a tradfn must be named; a tradfn is named by embedding ...).
• Names assigned in a dfn are local by default; names assigned in a tradfn are global unless specified in a locals list.
• Locals in a dfn have lexical scope; locals in a tradfn have dynamic scope, visible in called functions unless shadowed by their locals list.
• The arguments of a dfn are named ⍺ and ⍵ and the operands of a dop are named ⍺⍺ and ⍵⍵; the arguments and operands of a tradfn can have any name, specified on its leading line.
• The result (if any) of a dfn is unnamed; the result (if any) of a tradfn is named in its header.
• A default value for ⍺ is specified more neatly than for the left argument of a tradfn.
• Recursion in a dfn is effected by invoking ∇ or ∇∇ or its name; recursion in a tradfn is effected by invoking its name.
• Flow control in a dfn is effected by guards and function calls; that in a tradfn is by control structures and → (goto) and line labels.
• Evaluating an expression in a dfn not ending in assignment causes return from the dfn; evaluating a line in a tradfn not ending in assignment or goto displays the result of the line.
• A dfn returns on evaluating an expression not ending in assignment, on evaluating a guarded expression, or after the last expression; a tradfn returns on → (goto) line 0 or a non-existing line, or on evaluating a :Return control structure, or after the last line.
• The simpler flow control in a dfn makes it easier to detect and implement tail recursion than in a tradfn.
• A dfn may call a tradfn and vice versa; a dfn may be defined in a tradfn, and vice versa.

History

Kenneth E. Iverson, the inventor of APL, was dissatisfied with the way user functions (tradfns) were defined. In 1974, he devised "formal function definition" or "direct definition" for use in exposition.^[20] A direct definition has two or four parts, separated by colons:

name : expressionname : expression0 : proposition : expression1

Within a direct definition, ⍺ denotes the left argument and ⍵ the right argument. In the first instance, the result of expression is the result of the function; in the second instance, the result of the function is that of expression0 if proposition evaluates to 0, or expression1 if it evaluates to 1. Assignments within a direct definition are dynamically local. Examples of using direct definition are found in the 1979 Turing Award Lecture^[21] and in books and application papers.^{[22][23][24][25][9]}

Direct definition was too limited for use in larger systems. The ideas were further developed by multiple authors in multiple works^{[26]:§8[27][28]:§4.17[29][30][31][32]} but the results were unwieldy. Of these, the "alternative APL function definition" of Bunda in 1987^[31] came closest to current facilities, but is flawed in conflicts with existing symbols and in error handling which would have caused practical difficulties, and was never implemented. The main distillates from the different proposals were that (a) the function being defined is anonymous, with subsequent naming (if required) being effected by assignment; (b) the function is denoted by a symbol and thereby enables anonymous recursion.^[9]

In 1996, John Scholes of Dyalog Limited invented direct functions (dfns).^[1][6][7] The ideas originated in 1989 when he read a special issue of The Computer Journal on functional programming.^[33] He then proceeded to study functional programming and became strongly motivated ("sick with desire", like Yeats) to bring these ideas to APL.^[6][7] He initially operated in stealth because he was concerned the changes might be judged too radical and an unnecessary complication of the language; other observers say that he operated in stealth because Dyalog colleagues were not so enamored and thought he was wasting his time and causing trouble for people. Dfns were first presented in the Dyalog Vendor Forum at the APL '96 Conference and released in Dyalog APL in early 1997.^[1] Acceptance and recognition were slow in coming. As late as 2008, in Dyalog at 25,^[34] a publication celebrating the 25th anniversary of Dyalog Limited, dfns were barely mentioned (mentioned twice as "dynamic functions" and without elaboration). As of 2019, dfns are implemented in Dyalog APL,^[19] NARS2000,^[35] and ngn/apl.^[36] They also play a key role in efforts to exploit the computing abilities of a graphics processing unit (GPU).^[37][9]

References

1. Scholes, John (October 1996). "Direct Functions in Dyalog APL" (PDF). Vector. 13 (2). Retrieved 16 September 2019.
2. Scholes, John (1998–2019), Direct Functions Reference Card, retrieved 26 September 2019
3. Scholes, John (April 2001). "D: A Functional Subset of Dyalog APL". Vector. 17 (4). Retrieved 21 September 2019.
4. Scholes, John (13 September 2009). Introduction to D-functions: 1 of 2 (video). Dyalog '09 User Conference. Retrieved 21 September 2019.
5. Scholes, John (13 September 2009). Introduction to D-functions: 2 of 2 (video). Dyalog '09 User Conference. Retrieved 21 September 2019.
6. Scholes, John (31 October 2018). Dfns—Past, Present and Future (video). Dyalog '18 User Meeting. Retrieved 21 September 2019.
7. Scholes, John (31 October 2018), Dfns—Past, Present and Future (text) (PDF), Dyalog '18 User Meeting, retrieved 21 September 2019
8. Scholes, John (1998–2019), Direct Functions Workspace, retrieved 2019-09-15
9. Hui, Roger; Kromberg, Morten (June 2020). "APL Since 1978". Proceedings of the ACM on Programming Languages. 4 (HOPL): 1–108. doi:10.1145/3386319. S2CID 218517570. Retrieved 17 June 2020.
10. Hui, Roger (27 November 2016), A History of APL in 50 Functions, retrieved 17 September 2019
11. Hui, Roger (18 July 2016), APL Exercises, retrieved 24 September 2019
12. Weisstein, Eric W., Bertelsen's Number, MathWorld, A Wolfram Web Resource, retrieved 26 September 2019
13. Scholes, John (1998–2019), "Factorial", DFNS Workspace, retrieved 20 September 2019
14. Scholes, John (1998–2019), "Determinant", DFNS Workspace, retrieved 20 September 2019
15. Weisstein, Eric W., Partition Function P, equation 11, MathWorld, A Wolfram Web Resource, retrieved 3 October 2019
16. Hardy, G.H.; Ramanujan, S. (1918), "Asymptotic Formulæ in Combinatory Analysis" (PDF), Proceedings of the London Mathematical Society, 17 (2), retrieved 24 December 2019
17. Aho, A.V.; Hopcroft, J.E.; Ullman, J.D. (1974), The Design and Analysis of Computer Algorithms, Addison-Wesley
18. Bentley, Jon (August 1983). "Programming Pearls". Communications of the ACM. 26 (8 and 9).
19. Dyalog (15 August 2019). Dyalog Programming Reference Guide, version 17.1, Dfns & Dops, pp. 133-147 (PDF). Dyalog Ltd. Retrieved 30 September 2019.
20. Iverson, Kenneth E. (1974), "Chapter 10, Formal Function Definition", Elementary Functions, IBM Corporation, retrieved 18 September 2019
21. Iverson, Kenneth E. (August 1980). "Notation as a Tool of Thought". Communications of the ACM. 23 (8): 444–465. doi:10.1145/358896.358899. Retrieved 8 April 2016.
22. Iverson, Kenneth E. (1976). Elementary Analysis. APL Press.
23. Orth, D.L. (1976). Calculus in a New Key. APL Press.
24. Hui, Roger (May 1987). "Some Uses of { and }". APL 87 Conference Proceedings. Retrieved 15 April 2016.
25. McDonnell, E.E. (May 1987), "Life: Nasty, Brutish, and Short", APL 87 Conference Proceedings, retrieved 6 October 2019
26. Iverson, Kenneth E. (26 April 1978), "Operators and Functions", Research Report Number #RC7091, IBM Corporation, retrieved 2019-09-19
27. Iverson, Kenneth E.; Wooster, Peter (September 1981). "A Function Definition Operator". APL81 Conference Proceedings, APL Quote Quad. 12 (1).
28. Cheney, Carl M. (March 1981), APL*Plus Nested Array System Reference Manual (PDF), STSC, Inc., retrieved 18 September 2019
29. Iverson, Kenneth E. (6 January 1983), Rationalized APL, I. P. Sharp Associates, retrieved 2019-09-19
30. Iverson, Kenneth E. (September 1987). "A Dictionary of APL". APL Quote Quad. 18 (1): 5–40. doi:10.1145/36983.36984. S2CID 18301178. Retrieved 19 September 2019.
31. Bunda, John (May 1987). "APL Function Definition Notation". APL87 Conference Proceedings, APL Quote Quad. 17 (4).
32. Hui, Roger; et al. (July 1990). "APL\?". APL90 Conference Proceedings, APL Quote Quad. 20 (4). Retrieved 2019-09-10.
33. Wadler, Philip L.; et al. (1 January 1989). "Special Issue on Functional Programming". The Computer Journal. 32 (2).
34. Dyalog (September 2008). "Dyalog at 25" (PDF). Vector. Retrieved 2019-09-20.
35. Smith, Bob (2006–2019), NARS2000, retrieved 18 September 2019
36. Nickolov, Nick (September 2013). "Compiling APL to JavaScript". Vector. 26 (1). Retrieved 19 September 2019.
37. Hsu, Aaron (2019). A Data Parallel Compiler Hosted on a GPU (PDF) (Ph.D. thesis). Indiana University. Retrieved 25 December 2019.

External links

• Official website, Dyalog