# Yet Another Haskell Tutorial/Language advanced/Solutions

< Yet Another Haskell Tutorial | Language advanced(Redirected from Haskell/YAHT/Language advanced/Solutions)

## Contents

## 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) []