# Yet Another Haskell Tutorial/Language advanced/Solutions

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

## Sections and Infix Operators

edit## Local Declarations

edit## Partial Application

editFunction `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

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