# Yet Another Haskell Tutorial/Language advanced/Solutions

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

## Sections and Infix OperatorsEdit

## Local DeclarationsEdit

## Partial ApplicationEdit

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 MatchingEdit

## GuardsEdit

## Instance DeclarationsEdit

### The `Eq` ClassEdit

### The `Show` ClassEdit

### Other Important ClassesEdit

#### The `Ord` ClassEdit

#### The `Enum` ClassEdit

#### The `Num` ClassEdit

#### The `Read` ClassEdit

### Class ContextsEdit

### Deriving ClassesEdit

## Datatypes RevisitedEdit

### Named FieldsEdit

## More ListsEdit

### Standard List FunctionsEdit

### List ComprehensionsEdit

## ArraysEdit

## Finite MapsEdit

## LayoutEdit

## The Final Word on ListsEdit

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