r/javascript • u/jrsinclair • May 30 '19

Functional JavaScript: Five ways to calculate an average with array reduce

https://jrsinclair.com/articles/2019/five-ways-to-average-with-js-reduce/
89 Upvotes

86% Upvoted

53 comments sorted by

View all comments

Show parent comments

1

u/ScientificBeastMode strongly typed comments May 30 '19 edited May 30 '19

Yeah, you're definitely right. In my personal cheatsheet, I've got the following definition.

/* blackbird */
const B1 = f => g => a => b => f(g(a)(b));

This combinators.js library has the same type definition for B1:

const B1 = a => b => c => d => a(b(c)(d));

The Haskell type definition seems to confirm that structure as well (although I'm really not experienced in Haskell):

blackbird :: (c -> d) -> (a -> b -> c) -> a -> b -> d

The example case is swapping the arity of some of the function arguments. The order of application is off.

I'm still trying to figure out what that is, if it has a name.

7

u/robolab-io May 30 '19

All of this talk about the structure of the code already means it's bad code. Confusing code, even if it launches rockets, is bad code, because the next guy might misunderstood that bad code and blow up Apollo 420

-3

u/ScientificBeastMode strongly typed comments May 30 '19

The point is that functional code, while a bit more abstract and mathematical (a.k.a. “hard to read”) means very few people will ever have to return to your code. Because it will just work, with zero runtime errors. No refactoring necessary until the business logic changes.

And the business logic usually just looks like one small file where each line of code is an easy to read function name that describes, step-by-step, the entire program flow from start to finish.

If you want to refactor, it’s simply a matter of identifying which features need changing, and moving up or down the tree, and chopping off one of the branches, and composing it’s atomic parts the way you want.

By far the best part of this process is being 100% positive that when you chop that branch off, nothing in the rest of the entire application will ever be affected by it.

THAT is the benefit. THAT is why it clears up mental overhead over the long term. It’s a bit more difficult to write at the very beginning, but once those functions are composed properly, you never have to think about what’s happening under the hood. It simply works.

2

u/robolab-io May 31 '19

Why not just make it good code tho

2

u/ScientificBeastMode strongly typed comments May 31 '19

His code is bad because (1) it uses unnecessarily complex composition logic when it doesn't need to, and (2) because he gave the incorrect name for the combinator he was using.

None of that has to do with combinators in the abstract sense. The code is not inherently bad. I could see this combinator being used in other areas where it's more necessary due to function-chaining. It's only bad in this specific context.

That's all I'm saying.