# Yet Another Haskell Tutorial/Language advanced/Solutions

(Redirected from Haskell/YAHT/Language advanced/Solutions)

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