Anonymous Functions/Operators/Hyperators

Anonymous functions and operators are a one-line grouping of one or more statements (separated by diamonds) enclosed in braces such as {(+⌿⍵)÷≢⍵}. This syntax is useful for one-line functions and operators to complement the existing definition types of user-defined: ∇ Z←avg R, trains: (+⌿ ÷ ≢), and derived: ,∘⍋∘⍋∘,.

Function Arguments

To define an anonymous function, use ⍺ as the (optional) left argument, ∇ as the name of the anonymous function (for recursion), and ⍵ as the name of the right argument. For example,

      {s←(+/⍵)÷2 ⋄ √×/s-0,⍵} 3 4 5 ⍝ Heron's formula for triangle's area
6

Operator Operands

To define an anonymous operator, use the above special names along with ⍺⍺ as the name of the left operand, ∇∇ as the name of the operator (for recursion), and ⍵⍵ as the name of the right operand. If neither ⍺⍺ nor ⍵⍵ appears as a token (outside of character constants) between the braces, then the object is a function, not an operator. For example,

f←{∘.⍺⍺⍨⍳⍵}
=f 4 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1	⌈f 4 1 2 3 4 2 2 3 4 3 3 3 4 4 4 4 4	*f 4 1  1  1   1 2  4  8  16 3  9 27  81 4 16 64 256	≤f 4 1 1 1 1 0 1 1 1 0 0 1 1 0 0 0 1

Default Value For Left Argument

User-defined functions allow you to specify in their headers that the left argument is optional as in ∇ Z←{L} foo R. This behavior is also available to anonymous functions/operators by including a statement that assigns a value to ⍺. If ⍺ does not have a value when that statement is encountered, the statement is executed; if not, that entire statement is ignored including any side effects. This behavior obviates using 0=⎕NC '⍺' to test for a value in ⍺.

For example,

      f←{⍺←2 ⋄ ⍺√⍵}
      f 16
4
      3 f 27
3
      f←{⎕←⍺←⍵ ⋄ (⍳⍺)∘.⍺⍺⍳⍵}
      ⌊f 4
4
1 1 1 1
1 2 2 2
1 2 3 3
1 2 3 4
      3⌊f 4
1 1 1 1
1 2 2 2
1 2 3 3

As a consequence of this rule, regardless of whether the anonymous function is called monadically or dyadically, any second or subsequent statements that assign a value to ⍺ are always ignored.

Valences

For anonymous functions (and operators), if ⍺← appears as a sequence of tokens (outside of character constants), then the object is an ambivalent (derived) function; otherwise, if ⍺, appears as a token (outside of character constants), the function is dyadic-only (derived) function; otherwise (⍺ doesn't appear at all) it is monadic-only (derived) function.

For anonymous operators, if ⍵⍵ appears as a token (outside of character constants), then the operator is dyadic, otherwise it is monadic.

For example,

      {⍵}2
2
      1{⍵}2
VALENCE ERROR
      1{⍵}2
       ^
      1{⍺+⍵}2
3
      {⍺+⍵}2
VALENCE ERROR
      {⍺+⍵}2
      ∧
      {⍺←2 ⋄ ⍺+⍵}2
4
      3{⍺←2 ⋄ ⍺+⍵}2
5

Restrictions

• Anonymous functions/operators may not assign anything to any of the special names (∇, ⍵, ⍺⍺, ∇∇, ⍵⍵) except for ⍺. Any attempt to do so signals a SYNTAX ERROR.
• For the moment, anonymous functions/operators may be written on one line only.
• As a consequence of the above one-line restriction, anonymous functions/operator may not contain comments.
• None of the special names may be erased, via ⎕EX or otherwise.
• All variables to which an assignment is made are automatically localized to the anonymous function/operator, so (unlike user-defined functions) a direct assignment inside an anonymous function/operator cannot affect the value of a variable defined higher up in the execution chain unless it is made via a user-defined function or execute as in

      L←⍳9 ⋄ ⎕←{L←"abc" ⋄ ⍵}23
23
      L
1 2 3 4 5 6 7 8 9
      L←⍳9 ⋄ ⎕←{⍎'L←"abc"' ⋄ ⍵}23
23
      L
abc