Yet Another Haskell Tutorial/Language advanced/Solutions

Yet Another Haskell Tutorial
Getting Started
Language Basics (Solutions)
Type Basics (Solutions)
IO (Solutions)
Modules (Solutions)
Advanced Language (Solutions)
Advanced Types (Solutions)
Monads (Solutions)
Advanced IO

Sections and Infix Operators edit

Local Declarations edit

Partial Application edit

Function func3 cannot be converted into point-free style. The others look something like:

func1 x = map (*x)

func2 f g = filter f . map g

func4 = map (+2) . filter (`elem` [1..10]) . (5:)

func5 = flip foldr 0 . flip . curry 

You might have been tempted to try to write func2 as filter f . map, trying to eta-reduce off the g. In this case, this isn't possible. This is because the function composition operator (.) has type (b -> c) -> (a -> b) -> (a -> c). In this case, we're trying to use map as the second argument. But map takes two arguments, while (.) expects a function which takes only one.

Pattern Matching edit

Guards edit

Instance Declarations edit

The Eq Class edit

The Show Class edit

Other Important Classes edit

The Ord Class edit

The Enum Class edit

The Num Class edit

The Read Class edit

Class Contexts edit

Deriving Classes edit

Datatypes Revisited edit

Named Fields edit

More Lists edit

Standard List Functions edit

List Comprehensions edit

Arrays edit

Finite Maps edit

Layout edit

The Final Word on Lists edit

We can start out with a recursive definition:

and [] = True
and (x:xs) = x && and xs

From here, we can clearly rewrite this as:

and = foldr (&&) True

We can write this recursively as:

concatMap f [] = []
concatMap f (x:xs) = f x ++ concatMap f xs

This hints that we can write this as:

concatMap f = foldr (\a b -> f a ++ b) []

Now, we can do point elimination to get:

     foldr (\a b -> f a ++ b) []
==>  foldr (\a b -> (++) (f a) b) []
==>  foldr (\a -> (++) (f a)) []
==>  foldr (\a -> ((++) . f) a) []
==>  foldr ((++) . f) []