3 ms·

Using right-associativity of function types, and by sugaring the lambda into another function argument, we can rewrite this as (*-) :: (a -> b -> c) -> b ->

Using right-associativity of function types, and by sugaring the lambda into another function argument, we can rewrite this as (*-) :: (a -> b -> c) -> b -> a -> c (*-) f x y = f y x This reveals that (*-) is simply flip, which is in the Prelude (re-exported from Data.Function). Alternatively, Hoogling the original type signature will reveal the same thing. So the example doesn't require any new functions: import Data.Function ((&)) xs :: [Int] xs = 5 & flip take [1, 2, 3] & filter (/= 1) & head & flip take [1, 2, 3] In general, it's common in Haskell to use flip, curry/uncurry, and other higher-level functions to manipulate functions so they fit into the needed context.

eru 6y ago
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.
- johnday 6y ago
  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])
  - eru 6y ago
    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.
    - johnday 6y ago
      Oh good lord, that's horrible!

eru 6y ago

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.

johnday 6y ago
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])
- eru 6y ago
  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.
  - johnday 6y ago
    Oh good lord, that's horrible!