# Under

(Redirected from Close Under)
 `⍢`

Under (`⍢`), or Dual (`¨`), is a primitive dyadic operator which takes two function operands. It pre-processes its argument(s) with the monadic right operand, before applying the left operand on/between the result(s), then undoing the pre-processing.[1]

## Model

In dialects that support user-defined operators and invertible functions, it can be defined as (or similar):

`      _U_ ← {⍺←{⍵ ⋄ ⍺⍺} ⋄ ⍵⍵⍣¯1⊢(⍵⍵ ⍺)⍺⍺(⍵⍵ ⍵)}`

## Examples

The following example solves a LeetCode problem which asks to add two numbers given as reversed digit lists:

```
2 4 3 +_U_(10⊥⌽) 5 6 4
7 0 8```

First, each argument is reversed, then decoded from base 10. The addition is performed. Finally, the result is encoded to base 10 and reversed.

## Close composition

In SHARP APL and J, Under is implemented as a close composition, meaning that (using SHARP syntax) `f¨g` has the overall function rank of `g`. This allows `¨>` to serve the purpose of Each from a nested APL. J uses `&.` for the close form and `&.:` for the rankless form.

## History

The most widely known form of Under for much of APL's history was SHARP APL's Dual operator, written `¨` and defined as a close composition. It was presented by Ken Iverson and Bob Bernecky with the name "with" in 1980,[2] and implemented for only a small number of right operands in 1981.[3] The name "Dual" was used in Rationalized APL in 1983, and the full SHARP implementation using function rank was completed just after.[4] Iverson changed the name to Under for his 1987 A Dictionary of APL, and J uses this name as well. It includes both a close form `&.` like SHARP and a non-close form `&.:`.

However, Iverson had defined the Dual operator with glyph `⍢` in his 1978 paper Operators and Functions,[5] using a non-close form because function rank had not yet been invented. NARS featured this operator in 1981, preceding SHARP's limited implementation. Roger Hui proposed Under with the same definition as a potential addition to Dyalog APL at Dyalog '15, and it was added to both Extended Dyalog APL and dzaima/APL in 2018.

Structural Under was developed by Marshall Lochbaum around 2017,[6] and was included in Extended Dyalog initially and added to dzaima/APL in 2020. Later dzaima would implement `⍢×` and `⍢|` in the same spirit, now featured in dzaima/APL and dzaima/BQN. The language BQN has included structural and computational Under, using the glyph `⌾`, since its initial design in 2020. Structural Under also appears in Kap and Uiua, and is implemented for a small number of cases in J version 9.5 (2023).