BPL Function Trains and Operators

Writing functions without ⍵

One way to write your own function is with braces, like {(+/⍵)÷≢⍵}, where ⍵ stands for the data passed into the function. In this dialog we build new functions by combining existing functions, without ever mentioning the data. This style is called tacit (meaning "unspoken": the argument is never named). It is shorter, it reads like a sentence once you're used to it, and some patterns run faster.

Glyphs and ideas this dialog teaches:

Other glyphs used along the way:

The data

We use a week of midday temperatures (°C, Monday to Sunday) and a short sentence.

1. Fix the left side: ↣ and the shorthand 2×

The right-tail arrow ↣ fixes a function's left argument. 2↣× means "put 2 on the left of ×, then wait for the right argument". In other words, it makes the function "times 2".

When the fixed left argument is a value, BPL lets us leave out ↣. Therefore 2× is the shorter way to write the same function. You can store either form under a name, just like a value.

A longer example: Celsius to Fahrenheit is "times 1.8, then add 32". BPL reads right to left, so 32+1.8× means "times 1.8, then 32 plus that".

2. Fix the right side: ↢

The two arrows form a pair. 2↣÷ fixes 2 as the left argument, making "2 divided by". ÷↢2 fixes 2 as the right argument, making "divide by 2", which is "halve".

Why not just write ÷2? Because a single ÷ with only a right side already means something else (reciprocal - one over the number), so ÷2 is just the value 0.5, not a function. ↢ makes it clear that the 2 belongs on the right.

3. Right and left: ⊢ ⊣

Two very simple functions that become useful in a moment:

• ⊢ (right) gives back what's on its right and ignores the left.
• ⊣ (left) gives back what's on its left and ignores the right.

With nothing on the left, both just give back their argument.

4. Three functions in a row: a fork

When three functions sit side by side, f g h, BPL reads (f g h) x as (f x) g (h x):

• apply the left function to x,
• apply the right function to x,
• combine the two results with the middle function.

A classic example: mean←+/÷≢ is (+/x) ÷ (≢x), the total divided by the count.

Another example: the range of the temperatures is the hottest minus the coldest. ⌈/ is the biggest and ⌊/ the smallest, so the fork ⌈/-⌊/ means (⌈/x) - (⌊/x).

The temperatures average about 14.1 and spread over 11 degrees (from 9 to 20).

5. Two functions in a row: an atop

When two functions sit side by side, f g, BPL applies g first and then f to its result: (f g) x is f (g x).

• ⌊mean means "round down the mean". (⌊ on its own rounds down to a whole number.)
• +/isvowel means "add up the isvowel answers", which counts the vowels.

6. Fixed functions inside a train

The functions from steps 1 and 2 can go inside a fork. Here are two everyday examples.

Keep the warm days. warm←14< asks "is 14 less than it?", which is "is it above 14?". Then the fork warm#⊢ means (warm x) # (⊢ x): use the yes/no answers to filter x itself (# keeps the items where the answer is yes).

Although hot receives only one argument, the fork sends that same argument down both branches:

hot←warm#⊢

This is equivalent to the explicit function:

hot←{(warm ⍵)#⍵}

Because a tacit function does not name ⍵, ⊢ supplies the role of the second ⍵: it receives temps and returns it unchanged while warm turns the other copy into a Boolean mask. Thinking of ⊢ as “holding onto the original input” is useful, although it does not actually store or delay the value.

Split into words. notspace←' '≠ asks "is it not a space?". Then the fork notspace⊆⊢ means (notspace x) ⊆ x: split x where it's not a space (⊆ cuts a list into pieces, keeping each run marked yes).

7. Atop as an operator: ∘

f∘g means the same as the atop f g from step 5: do g, then f to its result. Writing it with ∘ makes the joining explicit, and it also works with a value on each side: x f∘g y is f (x g y).

For example, ⌊∘÷ means "divide, then round down", which is whole-number division.

8. Two named functions side by side: ⁝

• Many functions in this dialog have names: mean, warm, split.
• Say we give ≢ (count) the name tally, and want the atop "split, then tally" (as in step 5).
• Writing tallysplit fails: two names touching are read as one name, which doesn't exist.
• ⁝ (the tricolon, typed Alt-:, new in BPL 0.1.76) goes between them. It keeps the two names apart and does no maths, so tally⁝split is the atop tally split.
• tally∘split from step 7 does the same job.

9. Hooks: a function on each side of ↢ or ↣

In steps 1 and 2, ↣ and ↢ had a value on one side. Put a function on both sides and you get a hook. A hook uses the argument x twice: once as it is, and once changed by one of the functions.

• f↢g x means x f (g x): do g to x, then f with x itself on the left.
• f↣g x means (f x) g x: do f to x, then g with x itself on the right.

So ×↢- 5 is 5 × (-5), which is ¯25, and -↣+ 5 is (-5) + 5, which is 0. ×↢⊢ is x × x: another way to square (⊢ gives back x, from step 3).

10. Rebuild hot and split as hooks

• Operators join from the left, so 14↣<↣# means (14↣<)↣#.
• 14↣< is "is 14 less than it?" (step 1). Then ↣# uses those yes/no answers on the left of #, with x itself on the right. So it keeps the warm days, just like hot from step 6.
• ' '↣≠↣⊆ works the same way: mark the non-spaces, then cut x with them. That's split from step 6.
• The new names end in H (for hook). They can't end in a digit, because a digit ends a name in BPL: hot2 would mean hot applied to 2.

Fixing versus hooking. In 14↣<, ↣ fixes the value 14 as the left argument of <, producing the function “is greater than 14?”. In 14↣<↣#, operators join from the left, so it parses as (14↣<)↣#. The second ↣ has a function on each side and therefore forms a hook: it combines the fixed function 14↣< with #; it does not fix one function as an argument of the other.

When hooks are useful in practice

A hook is useful when a function needs the input twice: one copy unchanged and one copy transformed.

f↢g    ⍝ x f (g x)
f↣g    ⍝ (f x) g x

A useful question is:

Do I need to calculate something from the data, then combine that result with the original data?

If so, a hook may be a natural fit.

Scale values relative to their maximum, with a fork

This fork is (⊢x) ÷ (⌈/x): the left branch returns x, while the right branch finds its maximum. It gives 0.25 0.5 1. This kind of normalization is useful when comparing measurements on different scales.

Subtract the mean from every value

This is x - mean x. It shows how far each value is above or below the average—a common operation in statistics and data analysis.

Test whether something is a palindrome

This is x ≡ (⌽x): compare the original value with its reversal.

So hooks are particularly valuable for comparing, testing, or combining data with a result calculated from that same data. When the calculation naturally has two branches and a combining function—as in relative—a fork may be clearer.

11. One argument on both sides, or swap: ⍨

⍨ (self / commute) does two jobs:

• With one argument, f⍨ x means x f x. So ×⍨ multiplies a number by itself: it squares.
• With two arguments, a f⍨ b swaps them: b f a. So 2-⍨10 is 10-2.

12. Change only some items: @ with positions

f@[positions] x applies f to just the items at those positions, and leaves every other item as it was. The positions go in square brackets and count from 0.

If you put a value where f goes, those items are simply replaced by that value. Here we replace the weekend (positions 5 and 6) with 0.

In 10+@[5 6] temps, 10+ is not another value placed to the left of @: it is shorthand for the function 10↣+, meaning “add 10”. The @ therefore applies that function only at positions 5 and 6.

Note that temps itself doesn't change: @ gives back a new list.

13. Change only items that pass a test: @ with a function

Instead of positions, you can put a yes/no function in the brackets. @ then changes only the items where it says yes.

cold←15> asks "is 15 greater than it?", which is "is it below 15?".

14. Do, work, undo: @ with a function on the right

@ has one more use, called under. f@g x means:

1. do g to x,
2. do f to the result,
3. undo g again.

Example: round down to one decimal place. ⌊ only rounds to whole numbers, so: multiply by 10, round down, divide by 10. Here are the three steps by hand first.

⌊@(10×) does all three steps. BPL works out by itself that the way to undo "times 10" is "divide by 10".

15. Run a function backwards: ⁻¹

Many functions can be undone. Writing ⁻¹ (a small raised "minus one") straight after a function gives its inverse: the function that undoes it.

• +\ makes a running total, so +\⁻¹ turns a running total back into the original list.
• toF (step 1) turns Celsius into Fahrenheit, so toF⁻¹ turns Fahrenheit back into Celsius. BPL works out the reverse steps (subtract 32, divide by 1.8) by itself.

16. Work on each row: ⍤ (rank)

• [… ⋄ …] writes a table row by row: ⋄ starts the next row. Here w holds two weeks of temperatures, one week per row.
• mean w goes wrong. +/ totals each row, but ≢ counts the rows (2), so it divides each week's total by 2.
• ⍤ (rank, typed Alt-1 t) says which pieces a function works on. mean⍤1 w applies mean to each piece of rank 1. A rank-1 array is a list, so each piece is one row.

Week 1 averages about 14.1 °C and week 2 about 14.3 °C.

17. Pair each row with a vector: ⍤ with two arguments

m has shape 2 3: axis 0 has 2 rows, and axis 1 has 3 columns. v has shape 3: it has only axis 0, of length 3.

Plain + is pervasive; it does not default to the last axis. BPL agreement aligns leading axes, so m+v tries to match axis 0 of m (length 2) with axis 0 of v (length 3). They do not agree, so the result is a LENGTH error.

+⍤1 changes the cells given to +. The rank-1 cells of m are its two rows, each of shape 3; the rank-1 cell of v is the whole vector, also shape 3. The single v cell is therefore paired with each row of m.

The rank also determines how many times the operand function is called. Here +⍤1 calls + twice—once for each rank-1 cell (row) of m:

1 2 3 + 100 200 300
4 5 6 + 100 200 300

At rank 0, the cells of m are its six individual numbers. A scalar right argument has an empty frame, so it can be reused for every cell: m+⍤0 10 calls scalar + six times. By contrast, m+⍤0 v would still give a LENGTH error: its frames would be 2 3 and 3, whose leading axes do not agree.

Note: The above BPL expression did not work as m+⍤0 10 so I used the new tricolon : glyph rather than explicit parentheses.

18. Braces vs trains, side by side

Here are two small functions written both ways: first with braces, then as a train. ≡ (match) checks that the braces version and the train version give exactly the same answer.

Palindrome: "the word matches its reverse". The fork ⊢≡⌽ means (⊢ x) ≡ (⌽ x): x matches reversed x.

Your turn

1. Make triple←3× and use it on 1 2 3.
2. Square the numbers 1 to 5 with sq. (↦5 gives 1 to 5.)
3. Convert 50 °F to Celsius with toF⁻¹.
4. Use @ to replace Monday's temperature (position 0) with 99.
5. Give ⌽ (reverse) the name rev, then use ⁝ to make the atop revwords←rev⁝split. Try it on s: it should list the words in reverse order.
6. Make cube as a hook: x × (x × x), and try it on 3. Hint: ×↢sq: do sq, then multiply by x itself.
7. Count the days in each week of w with ≢⍤1, and compare with plain ≢w. Hint: plain ≢ counts the rows.