A philosophical difference between Haskell and Lisp (2015)

Re:A philosophical difference between Haskell and Lisp (2015) by eru on Monday August 03, 2020 @12:03AM (#24034116)

If you don't like flip, you could also do

  xs :: [Int]
  xs =
    5
      & (`take` [1, 2, 3])
      & filter (/= 1)
      & head
      & (`take` [1, 2, 3])

But I'm not sure that's a better style than flip.

I really like `on` from Data.Function, too.

[ Parent | on HN ]

Re:A philosophical difference between Haskell and Lisp (2015) by johnday on Monday August 03, 2020 @05:51AM (#24035811)

For maximum readability I'd be tempted to write the lambdas explicitly.

  xs =
    5
      & (\n -> take n [1, 2, 3])
      & filter (/= 1)
      & head
      & (\n -> take n [1, 2, 3])

[ Parent | on HN ]

Re:A philosophical difference between Haskell and Lisp (2015) by eru on Monday August 03, 2020 @11:35PM (#24046287)

That might be a wise choice.

It depends on what you are used to and your tolerance thresholds.

In a code base I worked on professionally, I came across the following idiom

    f a b `flip` d

which at first used to confuse me to no end. Later I figured out that you are supposed to read it as:

    f a b <place-holder> d

and thus

    \c -> f a b c d

In the same vein that Scala uses an underscore in somewhat implicit anonymous function syntax.

I still wasn't really happy with that usage, but at least I see why someone thought it would make sense.

(Mostly I wasn't so happy because it only works for the penultimate argument. If the syntax had worked out so that

    f a `flip` c d

would mean

    \b -> f a b c d

I would have been more amenable to the idiom. But you need the ugly

   f a `flip` c `flip` d

for that case. And that's clearly worse than the lambda syntax.

[ Parent | on HN ]

Re:A philosophical difference between Haskell and Lisp (2015) by johnday on Sunday August 09, 2020 @01:40PM (#24101292)

Oh good lord, that's horrible!

[ Parent | on HN ]