I'm learning haskell, and I'm trying to rewrite a function using composition only
Here's the function I'm trying to refactor:
ceilingDiv a b = ceiling (a / b)
So far I managed to make it work using curry and uncurry but it feels dirty:
ceilingDiv = curry $ ceiling . uncurry (/)
Is there any way to do this more cleanly? I was thinking ceiling . div, but it doesn't work because (/) returns a function and ceiling takes a Double as its argument.
There's a fun site called https://pointfree.io - it provides a solution to your problem like this: ceilingDiv = (ceiling .) . (/). It looks ugly because point-free composition with multiple arguments is a pain. Sometimes it's achieved by using . sections like here, sometimes by using an Applicative instance of functions and the <*> operator.
I think your solution with curry-uncurry is nice. It deals with passing multiple arguments by wrapping them into one tuple.
Compositions with multiple arguments are usually best just left in point-ful form. None of the alternatives is as clean and clear. Do make use of composition- and grouping operators, but don't golf away arguments just for the sake of it.
ceilingDiv a b = ceiling $ a/b
What you can certainly do is eta-reduce the b argument
ceilingDiv a = ceiling . (a/)
but I'd leave it at that. Even that is IMO less clean than the original 2-argument form, because the division operator needs to be sectioned.
When directly passing compositions to a higher-order function then it can make sense to aim a bit more agressively point-free, to avoid lambda bindings. The composition package has a whole bunch of operators for composing with more arguments. In this case, you could use the indeed quite concise
ceilingDiv = ceiling .: (/)