Point-free style — writing functions without naming their arguments

Both lines produce the same result. x => double(x) names an argument purely to immediately hand it to another function unchanged — double already is a function that takes one argument and returns a value, so wrapping it in another function that does nothing but forward its input is pure overhead. Passing double directly is the point-free version: no named parameter, because none was actually needed.

The function composition lesson earlier in this domain showed combining functions with compose/pipe. Point-free style is what that composition looks like in practice — a chain of functions with no intermediate named variables at all:

The pipeline describes the sequence of transformations directly, without inventing throwaway names (trimmed, lower) that exist purely to connect one step to the next.

Point-free style isn't a goal in itself, and pushing it too far actively hurts readability — a long chain of unnamed function composition can become genuinely harder to follow than a version with a couple of well-named intermediate variables, especially once more than two or three functions are chained together. The actual, worthwhile version of this technique is narrow: drop an argument specifically when it's only being forwarded unchanged to another function, not as a blanket rule to eliminate every named parameter everywhere.

array.map(fn) isn't always interchangeable with array.map(x => fn(x)). JavaScript's map calls its function with three arguments — the item, its index, and the whole array. The point-free version hands all of them to fn; the wrapper passes only the item:

So the safe version of the rule is: drop the wrapper only when the function takes exactly one argument, or when you know it ignores the extras.

Recognizing array.map(fn) as already point-free — and knowing why array.map(x => fn(x)) is usually unnecessary rather than more explicit — is a small but real code-review-level skill: the wrapped version isn't wrong, but when fn takes a single argument it adds a layer of indirection that does nothing. Once you notice the pattern, spotting (and simplifying) it elsewhere becomes automatic — as long as you check the function's arguments first, as the parseInt trap above shows.