Pfthb

returnGreater :: (Ord a) => a -> a -> a
returnGreater a b
 | (a > b) = a
 | otherwise = b

returnGreatest2 :: (Ord a, Num a) => a -> a -> a -> (a, a)
returnGreatest2 a b c
 | (a > b) = (a, returnGreater b c)
 | otherwise = (b, returnGreater a c)

sumOfSquares :: (Num a) => (a, a) -> a
sumOfSquares (a, b) = a^2 + b^2

Given the above functions, I'm confused why let x = sumOfSquares . returnGreatest2 returns

<interactive>:13:24: error:
 • Couldn't match type ‘a -> a -> (a, a)’ with ‘(c, c)’
 Expected type: a -> (c, c)
 Actual type: a -> a -> a -> (a, a)
 • Probable cause: ‘returnGreatest2’ is applied to too few arguments
 In the second argument of ‘(.)’, namely ‘returnGreatest2’
 In the expression: sumOfSquares . returnGreatest2
 In an equation for ‘x’: x = sumOfSquares . returnGreatest2
 • Relevant bindings include
 x :: a -> c (bound at <interactive>:13:5)

but sumOfSquares $ returnGreatest2 3 5 7 does the right thing. Since the type coming out of returnGreatest2 is the same as the type sumOfSquares expects, I would think I'd be able to compose them.

Composition and currying can be a little confusing. sumOfSquares . returnGreatest2 is the same as x -> sumOfSquares (returnGreatest2 x), but the type of returnGreatest2 x is (Ord a, Num a) => a -> a -> (a, a). You need to pass all expected arguments before you finally get a value of type (Ord a, Num a) => (a, a) that is acceptable by sumOfSquares.

On the other hand, sumOfSquares $ returnGreatest2 3 5 7 is parsed the same as sumOfSquares $ (returnGreatest2 3 5 7); the ($) operator has lower priority than function application (or any other operator, for that matter).

To really compose the two functions, you need several layers of composition:

let f = ((sumOfSquares .) . ) . returnGreatest2

Both sides of (.) function are expected to be a single argument functions so it treats returnGreatest2 as a a -> (a -> a -> (a, a)). But sumOfSquares does not accept (a -> a -> (a, a)) as an argument. One way to do it is to use $ like you did and apply all the arguments, but you can also state first two arguments explicitly:

let x a b = sumOfSquares . returnGreatest2 a b
x :: (Num c, Ord c) => c -> c -> c -> c

this way the types will match.

You can try this

sumOfSquares . returnGreatest2 3 5 $ 7

$ has te lowest priority. returnGreatest2 3 5 is the function returnGreatest2 partially applied to 3 and 5 so still a function which accepts a single variable. So now you have two functions which accept a single variable:

• sumOfSquares


• returnGreatest2 3 5

You can compose them with . which is what . is meant for: composing functions with a single variable in and a single variable out.