[Androider]

I feel nothing has improved code readability like the recent mainstreaming of map/filter/fold/reduce and "const all the things". This type of code is so easy to follow, reason about and trivial to debug at every step, once you internalize the few primitive functions.

I don't think you need to necessarily memorize these transformation names, but writing these types of functions is all I seem to be doing these days, transforming one thing into another line for line.

[jacobr]

I feel the code I wrote while on this bandwagon is the hardest to understand for others and for me myself today.

    pullAllBy(pluck(things, 'bar').map(compose(xor, lol, rofl)).reduce(differenceWith('id'))

Just write your transformations inline and go work on the next feature.

[Androider]

The trick is to break that (on the dots) into three const assignments with descriptive names. Practically self-documenting, easily debuggable.

If you don't use the builtin transformations, you'll just end up re-implementing them, poorly. And adding to the cognitive overhead with new concepts. And I have to read your code with a fine-toothed comb to ensure it's really side-effect free. I don't advocate turning everything into a named function as in your example though, short one-off functions should all be inline IMO.

[splintercell]

I feel like the functional code you wrote was written to intentionally obfuscate what is being done. For instance, composing a bunch of methods inline doesn't have any utility for it unless you define what compose(xor, lol, rofl) really means.

Ideally this is how it should be written for maximum readability.

  things
  |> pluck('bar')
  |> map(xor)
  |> map(lol)
  |> map(rofl)
  |> reduce(differenceWith('id')

The code is written equally well without using pipe operator but the proposal to introduce it is in works [1].

Here is it using lodash (not even lodash-fp), and this is going to do a single for loop when executing because this is lazy.

  _.chain(things)
   .pluck('bar')
   .map(_.xor)
   .map(_.lol)
   .map(_.rofl)
   .reduce(_.differenceWith('id'))
   .value();

It's no less readable than the code you'd write using using unfolded transformations.

1. https://github.com/tc39/proposal-pipeline-operator

[gaastonsr]

I agree, but you shouldn't map 3 times when you can map once over the data.

   things
    |> pluck('bar')
    |> map(compose(rofl, lol, xor))
    |> reduce(differenceWith('id')

[splintercell]

I made my case against the compose in the post.

Composing xor, rofl, lol isn't any better (esp in terms of readability) than it is individual maps.

What would be better is this:

  const makeHilarious = compose(rofl, lol, xor);
  
  things
    |> pluck('bar')
    |> map(makeHilarious)
    |> reduce(differenceWith('id')

[jacobr]

This means that to change this code you first have to look for the makeHilarious definition, then the definitions of rofl, lol and xor, then figure out what they all do separately and together, and if you can change them without breaking anything else in your application.

    things
      .map(thing => x.bar)
      .map(thing => {
        // whatever happens in rofl
        // whatever happens in lol
      })
      .reduce((acc, thing) => {
        // more stuff
      }, {})

This is code that is easy to understand and safe to change. The maps could be combined into one function body if it's convenient.

[splintercell]

I anticipated that makeHilarious is more than once used method, even if it is not, once you look at it's definition, you understand the intent behind "xor -> rofl -> lol".

It is one thing to quickly be able to understand that the person is doing a xor, then a rofl and then a lol of each element of an array, and a whole another thing to understand what the combination of these three actions over an array means. The python school of "code is read more than it's written" heavily stresses on explaining how easily the code should be understandable the first time someone reads it, but not whether it's easy to reason about or not.

The beauty of declarative style programming isn't to get more readable code immediately, but rather that once you understand the vocabulary, how easy it is for you to understand and reason about the code.

For instance, imagine reading a novel which is written like this:

"After Jack was done from the place where he went to do things for money everyday, he entered an establishment which served drinks that get you inebriated for money. This establishment was one he frequented regularly and preferred it over the others. He asked the man behind the counter for a wheat fermented brewed drink. After putting the drink to his lips and pouring it in to his mouth, he felt a sense of calmness enter his mind. It pushed all the thoughts which occupied his mind away, as he earlier desired before entering this establishment."

As opposed to:

"Jack really needed a drink after hard day at work. He went to his favorite pub, and ordered his favorite beer. After finishing the pint, he finally felt relaxed."

The Python philosophy (which is permeated everywhere in imperative world) is to describe everything in the simplest possible terms just in case there are people who may not understand what work, pub, beer, bartender, and relaxed means. But this just prevents from understanding of the actual purpose of the code.

This is at least the basic philosophy behind not using for loops everywhere.

[disantlor]

the nice thing is that you can easily split that line up as much as makes sense, should you decide you need to access some intermediate form of the data. and you can use the variable names as a comment that explains what that chunk of transformations represents.

so someone reading over it can kind of skim down the left side and follow what's happening and scan to the right if they need to understand some part in detail

[VMG]

If only you could still recognize it as a transformation when it is inline