Lua pipes

Well, the good news is that this type of code is "referentially transparent", which means you can fill in the values and implementations and resolve it similar to how you would resolve a mathematical equation.
The problem it's solving is counting the spades point in a round of Regicide, a game where players play combos of 0 or more cards, for example the played combos could be this:
{ {ace_of_spades}, {queen_of_hearts}, {}, {five_of_diamonds, five_of_spades} }
We are only interested in combos that contain spades, so these ones:
{ {ace_of_spades}, {five_of_diamonds, five_of_spades} }
Only spades count, but if a combo contains at least one spades card, all cards in the combo count as spades, so the last combo of two fives actually counts as 10 spades:
{ 1, 10 }
Now sum it and you get 11. Done!
Let's do it in code:

1       apply(
2 attackers,
3 filter(any(
4  card.get_suit >> eq(spades)
5 ))
6 >> flatten
7 >> sum _of(regicide.card_value)
8)
LUA

Let's fill in the array of combos:

1       apply(
2 { {ace_of_spades}, {queen_of_hearts}, {}, {five_of_diamonds, five_of_spades} },
3 filter(any(
4  card.get_suit >> eq(spades)
5 ))
6 >> flatten
7 >> sum_of(regicide.card_value)
8)
LUA

The apply just applies the first value parameter to the second function parameter like so:

1(filter(any(
2  card.get_suit >> eq(spades)
3 ))
4 >> flatten
5 >> sum_of(regicide.card_value)
6))({ {ace_of_spades}, {queen_of_hearts}, {}, {five_of_diamonds, five_of_spades} })
LUA

We now pull out the first step of the pipeline and funnel the array of combos through it:

(   flatten
 >> sum_of(regicide.card_value)
)(filter(any(
   card.get_suit >> eq(spades)
  ), { {ace_of_spades}, {queen_of_hearts}, {}, {five_of_diamonds, five_of_spades} }))
LUA

The filter function applies the predicate to each combo individually, e.g. for the first one:
any(card.get_suit >> eq(spades))({ace_of_spades})
(card.get_suit >> eq(spades))(ace_of_spades)
eq(spades, card.get_suit(ace_of_spades))
eq(spades, spades)
true
So for the array of combos, we get true, false, false, true, which filters to { {ace_of_spades}, {five_of_diamonds, five_of_spades} }:

(   flatten
 >> sum_of(regicide.card_value)
)( { {ace_of_spades}, {five_of_diamonds, five_of_spades} } )
LUA

Next, we pull out the flatten:

sum_of(regicide.card_value)(flatten({ {ace_of_spades}, {five_of_diamonds, five_of_spades} })
LUA

It just flattens an array of arrays to an array:

 sum_of(regicide.card_value)({ ace_of_spades, five_of_diamonds, five_of_spades })
LUA

sum_of is just implemented as sum_of = sum << map:

 (sum << map)(regicide.card_value)({ ace_of_spades, five_of_diamonds, five_of_spades })
LUA

Pull out the map:

sum(map(regicide.card_value, { ace_of_spades, five_of_diamonds, five_of_spades }))
LUA

Resolve map:

sum( { 1, 5, 5 } )
LUA

Resolve sum:
11
Done!