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