Anonymous Functions/Operators/Hyperators

From NARS2000
Revision as of 16:05, 4 July 2013 by WikiSysop (talk | contribs)
Jump to navigationJump to search

Anonymous functions and operators are a one-line grouping of one or more statements all 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,

      3{√+/⍺ ⍵*2}4 ⍝ Pythagorean theorem
5
      {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 a dyadic-only (derived) function; otherwise ( doesn't appear at all) it is a 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

Guards

Scoping

Recursion

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