Instances where we can curry and convert anonymous functions to sections are easy to find, for example from Exercise 5.5: doubleEach” :: [Int] -> [Int] doubleEach” = map (*2)

map f (map g xs) = map (f.g) xs map (\x -> (x+1)/2) xs = map (/2) (map (+1) xs)

map ((/2).(+1)) xs

fix f = f (fix f) First, f takes the result of fix f, and second, the return type of f must be the same as the return type of fix. fix :: (a -> a) -> a Research shows that fix is the Fixed point combinator (or Y-combinator). Apparently this allows the definition of […]

power :: (a -> a) -> Int -> a -> a power f 0 = (\x -> x) power f n = (\x -> f (power f (n-1) x)) Since the function is called power, there is one obvious application that springs to mind, i.e. raising to a power: raise :: Int -> Int -> […]

twice :: (a -> a) -> a -> a twice f = (\x -> f (f x)) twice twice applies the function 4 times: twice twice f = twice (\y -> f (f y)) = (\x -> (\y -> f (f y)) ((\y -> f (f y)) x)) = (\x -> (\y -> f (f […]

appendr = foldr (flip (++)) [] appendr [x,y,z] = foldr (flip (++)) [] [x,y,z] = flip (++) x (flip (++) y (flip (++) z [])) = flip (++) x (flip (++) y ([] ++ z)) = flip (++) x (([] ++ z) ++ y) = (([] ++ z) ++ y) ++ x Running time of […]

applyAll :: [(a -> a)] -> a -> a applyAll [] x = x applyAll (f:fs) x = f (applyAll fs x)

applyEach :: [(a -> b)] -> a -> [b] applyEach [] _ = [] applyEach (f:fs) x = f x : applyEach fs x

ys :: [Float -> Float]