Haskell/YAHT/Language advanced/Solutions

From Wikibooks, open books for an open world
< Haskell‎ | YAHT‎ | Language advanced
Jump to: navigation, search
Haskell
Haskellwiki logo.png
Yet Another Haskell Tutorial
Preamble
Introduction
Getting Started
Language Basics (Solutions)
Type Basics (Solutions)
IO (Solutions)
Modules (Solutions)
Advanced Language (Solutions)
Advanced Types (Solutions)
Monads (Solutions)
Advanced IO
Recursion
Complexity

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