# Pair

The function `⋈` forms a list of all its arguments. When there's one argument, it's called "Enlist", and with two, it's called "Pair".

↗️
```    ⋈ "enlist"    # ⟨𝕩⟩
⟨ "enlist" ⟩

"pa" ⋈ "ir"   # ⟨𝕨,𝕩⟩
⟨ "pa" "ir" ⟩
```

It's usually preferable to use list notation directly for such arrays, because it's easy to add or remove any number of elements. Pair is useful when a standalone function is needed, for example to be used as an operand.

↗️
```    2‿4‿1 ⋈⌜ "north"‿"south"  # Cartesian product
┌─
╵ ⟨ 2 "north" ⟩ ⟨ 2 "south" ⟩
⟨ 4 "north" ⟩ ⟨ 4 "south" ⟩
⟨ 1 "north" ⟩ ⟨ 1 "south" ⟩
┘

⋈¨ "+-×÷"  # Glyphs to strings
⟨ "+" "-" "×" "÷" ⟩
```

Another common pattern is to use Pair in a train, giving the results from applying each of two functions.

↗️
```    'c' (+⋈-)  1‿2
⟨ "de" "ba" ⟩
```

For longer lists, this pattern can be extended with the function `<⊸∾`, which prepends a single element to a list.

↗️
```    "e0" <⊸∾ "e1" <⊸∾ "e2" ⋈ "e3"
⟨ "e0" "e1" "e2" "e3" ⟩
```

However, before making a long list of this sort, consider that your goal might be more easily accomplished with a list of functions.

↗️
```    6 (+ <⊸∾ - <⊸∾ × ⋈ ÷) 3
⟨ 9 3 18 2 ⟩

{6𝕏3}¨ +‿-‿×‿÷
⟨ 9 3 18 2 ⟩
```

## Pair versus Couple

Enlist and Pair are closely related to Solo and Couple, in that `⋈` is equivalent to `≍○<` and `≍` is equivalent to `>∘⋈`. However, the result of `⋈` is always a list (rank 1) while Solo or Couple return an array of rank at least 1.

↗️
```    "abc" ≍ "def"
┌─
╵"abc
def"
┘

"abc" ⋈ "def"
⟨ "abc" "def" ⟩
```

And the arguments to Couple must have the same shape, while Enlist takes any two arguments.

↗️
```    "abc" ≍ "defg"
Error: ≍: 𝕨 and 𝕩 must have equal shapes (⟨3⟩ ≡ ≢𝕨, ⟨4⟩ ≡ ≢𝕩)

"abc" ⋈ "defg"
⟨ "abc" "defg" ⟩
```

The difference is that Couple treats the arguments as cells, and adds a dimension, while Pair treats them as elements, adding a layer of depth. Couple is a "flat" version of Pair, much like Cells (`˘`) is a flat version of Each (`¨`). Pair is more versatile, but—precisely because of its restrictions—Couple may allow more powerful array operations on the result.

## Fill element

Enlist and Pair set the result's fill element, while list notation doesn't have to. So the following result is guaranteed:

↗️
```    4 ↑ "a"‿5 ⋈ "b"‿7
⟨ ⟨ "a" 5 ⟩ ⟨ "b" 7 ⟩ ⟨ " " 0 ⟩ ⟨ " " 0 ⟩ ⟩
```

This means that `⋈` may not always behave the same as the obvious implementation `{⟨𝕩⟩;⟨𝕨,𝕩⟩}`. However, `≍○<` and even `>∘{⟨𝕩⟩;⟨𝕨,𝕩⟩}○<` compute the result fill as `⋈` does and are identical implementations.