Ex 10 Solutions

Prof. Dr.
Ralf Hinze TU Kaiserslautern

M.Sc. Sebastian Schloßer
Fachbereich Informatik
AG Programmiersprachen
Functional Programming: Exercise 10

Sheet published: Friday, July 8th
Exercise session: Thursday, July 14th, 12:00
Exercise 10.1. Show that this definition of the Reader Monad fulfils the Monad laws:
newtype Reader env a = Reader {runReader :: env → a }

instance Monad (Reader env ) where
return x = Reader (\ → x )
>= g = Reader (\x → runReader (g (f x )) x )
(Reader f ) >
For the proof, we leave out the Reader constructor and runReader accessor function:
return x = \ → x
f >>= g = \x → (g (f x )) x
f >>= return return a >>= f

= { def. >
>= } = { def. >>= }
\x → return (f x ) x \x → f (return a x ) x
= { def. return } = { def. return }
\x → f x \x → f a x
= { extensionality } = { extensionality }
f f a
(f >>= g) >
>= h
= { def. inner >
>= }
(\x → (g (f x )) x ) >
>= h
= { def. >
>= }
\x → (h (g (f x )) x ) x
= { extensionality, read the remaining proof bottom-up }
\x → (\x → (h (g (f x )) x ) x ) x
= { def. >
>= }
\x → (g (f x ) >
>= h) x
= { def. outer >
>= }
f >>= \a → (g a >
>= h)
1
Exercise 10.2 (Skeleton: Perfect.hs). Consider the following data type for trees con-
taining exactly 2n (n ∈ N) elements:
type Pair a = (a, a)

data Perfect a = Zero a
| Succ (Perfect (Pair a))
a) Write a function
height :: Perfect a → Integer
that calculates the height of the tree.
height (Zero ) = 1
height (Succ t) = 1 + height t
b) Write a function
toList :: Perfect a → [a ]
that transforms the tree to a list.
toList (Zero x ) = [x ]
toList (Succ t) = [z | (x , y) ← toList t, z ← [x , y ]]
c) Provide a Functor instance for Perfect and prove that it satisfies the first functor law.
instance Functor Perfect where

fmap f (Zero x ) = Zero (f x )
fmap f (Succ t) = Succ (fmap (\(x , y) → (f x , f y)) t)
Base case: Zero x

Need to show: fmap id (Zero x ) = Zero x
fmap id (Zero x )
= { def. fmap }
Zero (id x )
= { def. id }
Zero x
Induction step: Succ t

Induction Hypothesis: fmap id t = t
Need to show: fmap id (Succ t) = Succ t
2
fmap id (Succ t)
= { def. fmap }
Succ (fmap (\(x , y) → (id x , id y)) t)
= { def. id }
Succ (fmap (\(x , y) → (x , y)) t)
= { def. id (specialized to pair type) }
Succ (fmap id t)
= { induction hypothesis }
Succ t
d) Write a function
mirror :: Perfect a → Perfect a
that mirrors the tree such that toList ◦ mirror = reverse ◦ toList.
mirror (Zero x ) = Zero x

mirror (Succ t) = Succ (fmap (\(x , y) → (y, x )) (mirror t))
e) Write a function
fromList :: [a ] → Maybe (Perfect a)
that transforms the list into a perfect tree. This is possible only if the list contains
exactly 2n (n ∈ N) elements.
fromList [ ] = Nothing
fromList [x ] = Just (Zero x )
fromList xs = fmap Succ (pass xs >>= fromList) where
pass :: [a ] → Maybe [(a, a)]
pass [ ] = Just [ ]
pass [ ] = Nothing
pass (x : y : zs) = fmap ((x , y):) (pass zs)
3
Exercise 10.3 (Skeleton: Lists.hs). Lists can be represented as functions:
newtype ChurchList a = CL (∀b.(a → b → b) → b → b)
The type ChurchList a is isomorphic to the type [a ]. The ChurchList a representation

takes a binary operation (a → b → b) and an initial value (b). It applies the operation to
all elements from the list plus the initial value in a right-associative way. Think of it as
an instance of the foldr function where the list has already been provided.
a) Provide representations for both list constructors:
nil :: ChurchList a
cons :: a → ChurchList a → ChurchList a
nil = CL $ \ r → r
cons x (CL xs) = CL $ \f r → f x (xs f r )
b) We also need a way to consume lists of type ChurchList a. Implement a function
foldr :: (a → b → b) → b → ChurchList a → b
that behaves like foldr for normal Haskell lists of type [a ].
foldr f y (CL xs) = xs f y
c) Provide a Functor instance for ChurchList, i.e. implement a function
fmap :: (a → b) → ChurchList a → ChurchList b
We could just use foldr :
fmap f xs = foldr (\x ys → cons (f x ) ys) nil xs
We can simplify it to a direct implementation:
fmap f (CL xs) = CL $ \g → xs (g ◦ f )
4
d) Implement functions
fromList :: [a ] → ChurchList a
toList :: ChurchList a → [a ]
that convert normal Haskell lists to our ChurchList a representation and vice verca.
fromList = foldr cons nil

toList = foldr (:) [ ]
Instead of using cons and nil , we can also provide a direct implementation:
fromList xs = CL $ \f r → foldr f r xs
e) Implement functions
safeHead :: ChurchList a → Maybe a

safeTail :: ChurchList a → Maybe (ChurchList a)
append :: ChurchList a → ChurchList a → ChurchList a
that correspond to head , tail and ++ for normal lists of type [a ]. Note that safeHead
and safeTail have a Maybe return type to handle empty input lists.
safeHead (CL xs) = xs (\a → Just a) Nothing

safeTail (CL xs) = snd (xs (\x ∼(r , ) → (cons x r , Just r )) (nil , Nothing))
append (CL xs) (CL ys) = CL $ \f r → xs f (ys f r )
The tilde (∼) in safeTail makes the pattern match lazya . The lambda expression
is equivalent to \x pair → let (r , ) = pair in (cons x r , Just r ). Lazy pattern
matching is required here to ensure that safeTail always is productive; think of e.g.
safeTail (fromList [1 . .]) which otherwise hangs without producing output.
safeHead and append are constant time operations, safeTail needs linear time. For
normal Haskell lists, head and tail are constant time, whereas ++ needs time linear
in the length of the first parameter.
In the interpreter, type :set +s to enable statistics and then compare:
iiii length $ foldr (+

+) [] (take 10000 (repeat [1]))
iiii length $ foldl (+
+) [] (take 10000 (repeat [1]))
iiii length $ foldr append nil (take 10000 (repeat (cons 1 nil )))
iiii length $ foldl append nil (take 10000 (repeat (cons 1 nil )))
a
https://wiki.haskell.org/Lazy_pattern_match

Ex 10 Solutions

Uploaded by

Copyright:

Available Formats

Ex 10 Solutions

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ex 10 Solutions

Uploaded by

Copyright:

Available Formats

Prof. Dr.

Ralf Hinze TU Kaiserslautern

Functional Programming: Exercise 10

newtype Reader env a = Reader {runReader :: env → a }

f >>= return return a >>= f

type Pair a = (a, a)

height :: Perfect a → Integer

that calculates the height of the tree.

that transforms the tree to a list.

instance Functor Perfect where

Base case: Zero x

Induction step: Succ t

mirror :: Perfect a → Perfect a

mirror (Zero x ) = Zero x

fromList :: [a ] → Maybe (Perfect a)

newtype ChurchList a = CL (∀b.(a → b → b) → b → b)

The type ChurchList a is isomorphic to the type [a ]. The ChurchList a representation

a) Provide representations for both list constructors:

b) We also need a way to consume lists of type ChurchList a. Implement a function

that behaves like foldr for normal Haskell lists of type [a ].

foldr f y (CL xs) = xs f y

c) Provide a Functor instance for ChurchList, i.e. implement a function

fmap :: (a → b) → ChurchList a → ChurchList b

We could just use foldr :

fmap f xs = foldr (\x ys → cons (f x ) ys) nil xs

We can simplify it to a direct implementation:

fmap f (CL xs) = CL $ \g → xs (g ◦ f )

fromList = foldr cons nil

safeHead :: ChurchList a → Maybe a

safeHead (CL xs) = xs (\a → Just a) Nothing

iiii length $ foldr (+

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.