|Functional Programming -- Exercises 4||TDA452 & DIT142 | LP2 | HT2011 | [Home]|
Here are some exercises designed to help you practice programming with IO, test data generation, and properties.
Please prepare yourself for these exercises by printing them out, and also printing out the code samples and documentation that is referred to by links.
If you do not have time to do all these exercises, don't worry. The exercises are intended to provide enough work to keep the most experienced students busy. If you do all exercises marked with an (*) you have probably understood this week's material.
look :: Eq a => a -> [(a,b)] -> Maybe b look x  = Nothing look x ((x',y):xys) | x == x' = Just y | otherwise = look x xysDefine a property prop_LookNothing that expresses that if the look function delivers Nothing, then the thing we were looking for was not in the table.
Also define a property prop_LookJust that expresses that if the look function delivers a result (Just y), then the pair (x,y) should have been in the table.
Also write one property prop_Look that combines prop_LookNothing and prop_Just into one property.
sequence :: Monad m => [m a] -> m [a] onlyIf :: Monad m => Bool -> m () -> m ()"sequence" takes a list of instructions resulting in a value of type a, and creates one big instruction that executes all of these, gathering all results into one result list. Example: the instruction "sequence [ readFile file | file <- files ]" reads the contents of all files in the list files, and produces the contents of each of the files.
"onlyIf" takes a boolean and an instruction, and creates an instruction that only executes the argument instruction if the boolean was True. If the boolean was False, nothing happens. Example "onlyIf failed tryAgain" executes the instructions tryAgain only if the boolean failed is True.
Hint: You might find it easier to think of the above functions having type:
sequence :: [IO a] -> IO [a] onlyIf :: Bool -> IO () -> IO ()
In this exercise, you are going to implement the "number guessing game" in Haskell.
Here is an example of how this might work:
Main> game Think of a number between 1 and 100! Is it 50? higher Is it 75? lower Is it 62? lower Is it 56? yes Great, I won!The text in italics is what the user types in. The other text is produced by your program.
Implement a function
game :: IO ()That plays one instance of this game.
You might need the following functions:
getLine :: IO String -- reads a line of user input putStrLn :: String -> IO () -- outputs one line of textBefore you start programming, think of a good guessing strategy for the computer that minimizes the number of guesses!
Haskell programs can generate instructions to be performed by the command shell using
system :: String -> IO ()
This is one way to run other programs from Haskell, for example. The String passed to system often differs, depending on whether it is the Linux shell or the Windows one which should obey the command. For example, to copy file A to file B under Linux, the string "cp A B" is used, while under Windows it would be "copy A B". As a result, programs which use system normally work only under one operating system, which is sad, but can't be helped.
Use system to write a program that
(You are supposed to copy the files one by one, not by constructing a command such as "cp * backup", because filename expansion isn't applied to strings passed to system.)
You will need to read the list of filenames in the current directory, and to find out how, you will need to consult the documentation of Haskell's standard libraries. Here's the link:
There are a lot of them! The one you want is called System.Directory--find its documentation, and figure out how to read the filenames in a directory.
You will also perhaps need to perform all of a list of actions. You may find the function
sequence :: Monad m => [m a] -> m [a]
useful for this. You must add
to your file if you want to use it.
If you want to, you can also use the standard functions createDirectory and copyFile from System.Directory (instead of the commands "mkdir" and "cp") to accomplish this.
Sometimes we want to generate lists of a certain length.
A. Write a generator
listOf :: Integer -> Gen a -> Gen [a]
such that listOf n g generates a list of n elements, where each element is generated by g. What property would you write to test that your generator behaves as it should?
B. Now use listOf to write a generator that generates pairs of lists of the same, random, length.
C.Take a look at the standard Haskell functions zip and unzip:
zip :: [a] -> [b] -> [(a,b)] unzip :: [(a,b)] -> ([a],[b])Write down two properties for these; one that says that zip is the inverse of unzip, and one that unzip is the inverse of zip. Note that unzip is not always the inverse of zip, so you need a condition! Could you make use of the generator you just defined?
A.Write a function "ordered" that checks if a list is ordered; each element in the list should be smaller than or equal to the next element.
B.Write a generator that generates random lists of integers that are sorted (ordered). You are not allowed to make use of the function sort! (And not of the generator orderedList from the lecture either...)
Hint: First generate a list of random, positive integers. Then, generate a first, random number in the list. Then, produce a list where the differences between each consecutive pair of elements is given by the list of positive integers.