Identity

An Identity function, or tack function, is one of the three primitive functions which returns one of its arguments with no modification:
 * Identity, Same, or Pass ( or  ) is monadic and returns its only argument.
 * Left Identity, or Left is dyadic and returns its left argument.
 * Right Identity, or Right is dyadic and returns its right argument.

The right tack glyph, when used for Right, is almost paired with Identity for the monadic case. Left tack,  is usually used for Identity as well, but may be given a different meaning, such as Stop (which returns the constant  ) in SHARP APL and APLX, or Hide (which returns the constant   as a shy result) in GNU APL.

Identity functions (Identity in particular) may be used like elements of syntax to break up stranding, or to force a shy result to be shown. They can also be combined with an array-oriented operator to perform structural manipulations on arrays. Identity functions are a central feature of tacit programming, in which functions and operators rather than names are used to direct the flow of arguments. The pairing of both Left and Right with monadic Identity makes it easier to design ambivalent functions which usefully work with one or two arguments.

Examples
The monadic Identity function simply returns its argument. The result of an identity function is never shy, even if the argument is. Thus the result of the second expression above is displayed, although the assignment  on its own would not produce any display.

Left and Right return the left and right arguments, respectively, when called dyadically.

Uses
As the left operand to Beside, Right makes the resulting derived function ignore its left argument (so the result is produced by a monadic invocation of the right operand, on the right argument). The same pattern can be produced by using Right as the right operand to Atop. In both cases the derived function, when called monadically, simply acts on the right argument, as there is no left argument to ignore. The mirror image—using only the left argument while ignoring the left—is attained by using Atop (either the operator, or a 2-train) with Left as the right operand.

Within a function train (as an "argument" function, that is, the rightmost function, or one an even number of steps away), Right indicates the right argument to the train, and Left indicates the left argument. The 3-train  thus applies Partition to the result of Not Equal to on both arguments and the right argument.

Structural manipulation
With Reduce, Left selects the first elements along the reduction axis, and Right selects the last. For example,  gives the first major cell of an array while   gives the first element along each row, for example the first column of a matrix. The combinations        are recognized idioms in Dyalog APL.

A Scan using Left extends the first element along each axis to the whole axis, while retaining the argument's shape. This is because a scan reduces on prefixes, and the first element of a prefix is the first element of the entire array. On the other hand, Right Scan doesn't change the argument, since the last element from each prefix gives the entire array.

Right Each checks the arguments for conformability and returns the right argument, possibly applying scalar extension or singleton extension; Left Each does the same for the left argument.

The outer product with Left adds the axes from the right argument to the left argument, while the outer product with Right adds the axes from the left argument to the right argument. In each case the resulting array is constant along any of the added axes. In the case of Right outer product, the result is composed of cells matching the right argument, and can also be obtained by reshaping the right argument.

Tutorials

 * Optima Systems blog: Left and Right Tack in Dyalog APL

Documentation

 * Dyalog: Left Tack, Right Tack
 * APLX: Left, Right, Pass