• Home
• Schedule
• Homework
• Resources
• Software
• Style guide

Optional exercise: SecretCode

This module is for those who are completely new to functional programming. It is an optional exercise, and will give you a chance to practice before the first in-class exercise. If you have questions about this exercise, please ask on the Ed platform or in office hours.

> module SecretCode where

Remember that you can execute the definitions in this module by loading it into ghci. In the terminal, you can use the command

  stack ghci SecretCode.hs

to automatically start ghci and load the module.

OK, we're going to write a Haskell program to encode and decode text files using a secret code.

We'll call it the Brown Fox code. Here's how it works:

- Replace each letter according to the following correspondence:

        "abcdefghijklmnopqrstuvwxyz"
    to  "thequickbrownfxjmpsvlazydg"

  But leave any non-letter characters alone.

- Then reverse the order of the lines in the file.

> import Data.Char
> import Data.Maybe
> import Test.HUnit
> import System.FilePath -- library for manipulating FilePaths.

First, we make a lookup list (aka association list) containing each pair of corresponding letters:

> code :: [(Char,Char)]
> code = zip ['a' .. 'z'] cypher ++ zip ['A' .. 'Z'] (map toUpper cypher)
>   where
>     cypher :: String
>     cypher = "thequickbrownfxjmpsvlazydg"

Now, how can we use this lookup list?

Association lists seem like they are probably a pretty common idiom, so let's check Hoogle to see if there is a function to look things up in them automatically...

What type would such a function have? In our case, we want something like:

    [(Char,Char)] -> Char -> Char

That is, the function should take a list that maps Chars to Chars and a specific Char, and it should return the corresponding Char from the list (if it is present). The first hit on Hoogle for this type is the standard library function lookup:

   lookup :: Eq a => a -> [(a,b)] -> Maybe b

Ignoring the Eq a part for now (we'll talk about it next week), this type makes a lot of sense. It's a bit more general than what we searched for, allowing the function to be called with different types for the "keys" and "values" of the association list to take on different, and lookup also returns a Maybe type because the thing we're looking up might not be in the list.

(Recall that a Maybe a is either Just v for some v of type a, or Nothing.)

So, we can use lookup to encode a particular character. If we don't have a mapping for a character in our code, (i.e. for punctuation) we should leave it alone.

> -- >>> encodeChar 'a' 
> -- 't'
> -- >>> encodeChar '.'
> -- '.
> encodeChar :: Char -> Char
> encodeChar c = case lookup c code of
>    Just x -> x
>    Nothing -> c 

> testEncodeChar = runTestTT $ TestList [ encodeChar 'a' ~?= 't',
>                                         encodeChar '.' ~?= '.']

We'll next need a way to encode a whole line of text. Of course, remembering that Strings are just lists of Chars, there is a perfect higher-order function in HigherOrder that we can use:

> -- >>> encodeLine "abc defgh"
> -- "the quick"
> encodeLine :: String -> String
> encodeLine = map encodeChar

> testEncodeLine = runTestTT $ TestList [encodeLine "abc defgh" ~?= "the quick"]

Finally, we need a function to encode a whole file. Remember, we want to reverse the order of the lines (so that the last line is first, and so on), then swap the letters in each. The reverse function in the standard library will come in handy.

However, we also need a way to break a file into lines - we could do this manually by folding over the String and checking for newlines, but this seems like a commonly used function, let's check Hoogle instead. Indeed, we find a function of type

String -> [String]

in the standard library to do just this. Furthermore, its counterpart of type

[String] -> String

So...

> encodeContent :: String -> String
> encodeContent = unlines . reverse . map encodeLine . lines

> testEncodeContent = runTestTT $
>   encodeContent "abc\n defgh\n" ~?= " quick\nthe\n"

Don't forget that the . operator is function composition. That is:

  (f . g) x = f (g x)

See if you can simplify your definition of encodeContent using this operator.

OK, now let's construct an IO action that actually reads in a file from disk, encodes it, and writes it back out. We can look at the Haskell Prelude to find functions for reading and writing files.

    readFile  :: FilePath -> IO String
    writeFile :: FilePath -> String -> IO ()

Your function should read from the file 'f', but shouldn't overwrite the file with the encoded version. In Haskell, FilePaths can be manipulated with functions in the System.FilePath library. For example, we can use the replaceExtension function to create a new file name for output.

> encodeFile :: FilePath -> IO ()
> encodeFile f = 
>   if takeExtension f == "code"
>     then putStrLn "Cannot encode .code files"
>     else do
>       let outFilePath = replaceExtension f "code"
>       
>       fcontents <- readFile f
>       writeFile outFilePath (encodeContent fcontents) 

Finally, let's put it all together into a "main" function that reads in a file name from the standard input stream and swizzles it:

> main :: IO ()
> main = do putStrLn "What file shall I encode?"
>           fn <- getLine
>           encodeFile fn
>           putStrLn "All done!"