function-composition

I'm trying to understand what the dot operator is doing in this Haskell code: sumEuler = sum . (map euler) . mkList The entire source code is below. My understanding The dot operator is taking the two functions sum and the result of map euler and the result of mkList as the input. But, sum isn't a function it is the argument of the function, right? So what is going on here? Also, what is (map euler) doing? Code mkList :: Int -> [Int] mkList n = [1..n-1] euler :: Int -> Int euler n = length (filter (relprime n) (mkList n)) sumEuler :: Int -> Int sumEuler = sum . (map euler) . mkList Put simply,

Ordinary function composition is of the type (.) :: (b -> c) -> (a -> b) -> a -> c I figure this should generalize to types like: (.) :: (c -> d) -> (a -> b -> c) -> a -> b -> d A concrete example: calculating difference-squared. We could write diffsq a b = (a - b) ^ 2 , but it feels like I should be able to compose the (-) and (^2) to write something like diffsq = (^2) . (-) . I can't, of course. One thing I can do is use a tuple instead of two arguments to (-) , by transforming it with uncurry , but this isn't the same. Is it possible to do what I want? If not, what am I misunderstanding

I have been reading Real World Haskell , and I am nearing the end, but a matter of style has been niggling at me to do with the (.) and ($) operators. When you write a function that is a composition of other functions you write it like: f = g . h But when you apply something to the end of those functions I write it like this: k = a $ b $ c $ value But the book would write it like this: k = a . b . c $ value Now, to me they look functionally equivalent, they do the exact same thing in my eyes. However, the more I look, the more I see people writing their functions in the manner that the book

I have seen a lot of functions being defined according to the pattern (f .) . g . For example: countWhere = (length .) . filter duplicate = (concat .) . replicate concatMap = (concat .) . map What does this mean? The dot operator (i.e. (.) ) is the function composition operator. It is defined as follows: infixr 9 . (.) :: (b -> c) -> (a -> b) -> a -> c f . g = \x -> f (g x) As you can see it takes a function of type b -> c and another function of type a -> b and returns a function of type a -> c (i.e. which applies the first function to the result of the second function). The function

Why does this typecheck: runST $ return $ True While the following does not: runST . return $ True GHCI complains: Couldn't match expected type `forall s. ST s c0' with actual type `m0 a0' Expected type: a0 -> forall s. ST s c0 Actual type: a0 -> m0 a0 In the second argument of `(.)', namely `return' In the expression: runST . return The short answer is that type inference doesn't always work with higher-rank types. In this case, it is unable to infer the type of (.) , but it type checks if we add an explicit type annotation: > :m + Control.Monad.ST > :set -XRankNTypes > :t (((.) :: ((forall