Array programming LLM Building Blocks with BQN

Atop is the simplest combinator. F of G is a concept well known in mathematics and used as is here. Atop is also the 2 Train - so basically you learnt 2 concepts in 1 go!

The only thing you need to remember is that both the arguments are passed to G and the result is sent to F.

As an example, consider +´√ 1‿4‿9. First we take square root of the array and then we add up the elements. Here we have already modifed the + which is normally used to add two arrays to a fold version. But, by placing the two functions +´ and √ next to each other, we create a 2-train.

You can instead use the explicit ∘ in between, which becomes useful for longer trains.

Over as in w F○G x is F(G(w), G(x)), that is apply G to both arguments (independently) and then apply F with these two as arguments.

Let's take an example. 2 {(𝕨×𝕨) + (𝕩×𝕩)} 3 is about squaring and adding the two operands. We use the explicit block notation {} to make this function, where we explicitly refer to the left (𝕨) and right (𝕩) arguments. Now, we see that multiplying the number with itself, can happen using the the Self operation, so the same thing can be refactored into 2 {(ט𝕨) + (ט𝕩)} 3. Try this out and see that this works.

Now, the Over pattern can be used here. We want to apply the "Square" function on both operands, first. Then we want to "Sum" them.

2 (+○(ט)) 3 is the same thing expressed using the Over combinator. In this version, we don't refer to the args explicitly anymore, instead having a single tacit function.

In the previous example, we had the same function applied on both args. Instead, let us now consider the following: 2 {(𝕨+𝕩) × (𝕨-𝕩)} 3. Add the two numbers, subtract the same two numbers and multiply the result.

Compare this with previous scenario:

1. You want to run 2 different functions.
2. You want these functions to take both inputs as arguments.

This can be massively simplified using the 3-Train to the following: 2 (+×-) 3. Note the use of the paranthesis when using 3-trains in-line. Instead if you define a function like H ← +×- ~, you can use it directly like ~2 H 3.

Look at the 3-train and think about this carefully. It is also called fork - you have the two outer functions and then the inner function acting on the result of those.

Between 3-trains and Atop (or 2-trains) all sorts of things can be done. Note that you can nest the 3-trains to make longer chains of functions.

In this junction, it is good to understand the identify functions left ⊣ and right ⊢.

The previous example with Over, can be re-written as 2 ((ט⊣)+(ט⊢)) 3.

Before and After can be thought of special cases of 3-trains. What if you don't want to run a function on both sides, but just one of those.

For example, consider a ← ⟨1, 4, 9, 6⟩. Now (⊏∨a) - a gives us difference between maximum and each element of a. If you notice the expression, we have 2 calls of a. This makes this nor a train, or tacit program. What can we do to make it into a single function call?

From before, we can apply a 3-train as: ((⊏∨)-⊣) a. Notice, that we don't want to do anything with the second argument, so we use the right identity function.

But, instead of this, we can use the built-in "before" as: (⊏∨)⊸- a, as in: call the function on the left first (before) on a, then call the second function with that and a itself (unmodified) as the args.

The same applies with After. Have a look at the diagrams in the linked documentation page, which are very useful to get the hang of Before and After.

We have more combinators, more complicated, in order:

1. Repeat ⍟
2. Choose ◶
3. Under ⌾

I will let you explore these. Reading only helps so much: you need to try composing a few to get some grip over these. Can't say I can use Under comfortably yet.