Hacker News Reader

Comment by lalaithion | Hacker News Reader

Having pointfree functions and curried application makes the functional example more readable, as it removes the obscuring lambdas:

    (reduce (+) . map (^2) . filter ((==1).(%3))) [1,2,3,4,5]

The above is pseudo-Haskell. If we want to

View on HN

In actual Haskell I would write it as

    sum [ n^2 | n <- [1..5], n % 3 == 1 ]

which seems to express the idea fairly directly and I'm fairly sure has a close analog in python.

python: sum([n * n for n in range(1,5,3)])

haskell: sum [n^2 | n <- [1,3..5]]

I just remembered haskell's "range" operator ".." can also take a step size.

['a', 'd' .. 'z'] => "adgjmpsvy"

yeah to me this just hollers for the kind of "pour it through the functions" approach we see in functional languages or even with Ramda.pipe in JS. Ezpz.

Or in functional rust

  (1..5)
    .into_iter()
    .filter(|i| i % 3 == 1)
    .map(|i| i * i)
    .sum();

I don't know if we really need a new syntax for map reduce.

That's also basically the same syntax as doing it in JS, aside from the lack of builtins:

    import { range } from 'ramda';

    range(1, 6)
      .filter(i => i % 3 === 1)
      .map(i => i * i)
      .reduce((a, b) => a + b, 0);

Or, if you're using the pipeline operator (experimental, stage 1, nobody can quite decide on exactly the syntax but this gives the rough idea):

    import { range, sum } from 'ramda';

    range(1, 6)
      |> x => x.filter(i => i % 3 === 1)
      |> x => x.map(i => i * i)
      |> sum

We can get rid of these arrows using ramda's curried list functions, at the expense of being slower and harder to read but making us feel more clever:

  pipe(
    range,
    filter(pipe(
      modulo(__, 3), // x => x % 3
      equals(1) // y => y === 1
    )),
    map(flip(Math.pow)(2)),
    sum
  )(1,6)

Reply on news.ycombinator.com