Understanding IO

This exercise asks us to solve two different problems: First, we’d like to add up all of the numbers passed in as command line arguments, next we’d like to let the user pick an operation other than addition. We’ll take this solution in two parts. First, let’s work on simply adding up the numbers passed in as command line arguments.

To do this, we’ll need to:

1. get the command line arguments
2. conver them to numbers
3. add the list of numbers
4. print it out

There are a couple of ways to solve this. One choice we’ll need to make is whether we’d like to use (>>=) or do notation. Let’s look at both options, starting with (>>=). We can write a short point-free implementation of this function as a one-liner:

runBind :: IO ()
runBind = getArgs >>= print . sum . map read

This is a fairly idiomatic way to write the function, but if you find point-free code hard to read, we can refactor this a bit to add some intermediate bindings that might make it more readable. First, we can factor out the pure code that transforms the list of strings we get from getArgs into the sum that we want to display:

runBind :: IO ()
runBind = getArgs >>= print . sumInputs
  where
    sumInputs inputs = sum $ map read inputs

We’re still composing print with sumInputs in this example. If you want to go another step, we can add another binding for printing out the results of summing the inputs:

runBind :: IO ()
runBind = getArgs >>= showSum
  where
    sumInputs inputs = sum $ map read inputs
    showSum inputs = print $ sumInputs inputs

Alternatively, we can stop using (>>=) and, instead use do notation. Let’s take a look at a similar implementation built around do:

runDo :: IO ()
runDo = do
  arguments <- getArgs
  let sumOfArgs = sum $ map read arguments
  print sumOfArgs

You’ll notice in this example that do notation tends to encourage a somewhat more explicit style of programming with more named bindings and less composition. You can choose whichever style you prefer. For the next part of this exercise, we’ll stick do notation.

Building a version of our program that allows the user to select an operation isn’t much more difficult conceptually than supporting only addition, but the code we need to write will be more complicated due to additional error handling. Let’s take a look at the program, and then walk through how it works:

runCalculator :: IO ()
runCalculator = do
  args <- getArgs
  case args of
    [] -> putStrLn argsError
    [_] -> putStrLn argsError
    (op:numStrs) ->
      case getOperation op of
        Just f ->
          let nums = map read numStrs
          in print $ f nums
        Nothing -> putStrLn $ opError op
  where
    argsError =
      "Missing arg(s). Need an operator and at least 1 number"
    opError op =
      op <> " - Unrecognized Operator. Please use one of +,*,-,/"
    getOperation op =
      case op of
        "+" -> Just sum
        "*" -> Just product
        "-" -> Just $ foldl1 (-)
        "/" -> Just $ foldl1 div
        _ -> Nothing

In the earlier versions of our program, after getting the arguments we immediately converted them to numbers, then added them up. Now, we need to deal with a number of different error cases. The first thing we do in this version of our program is to check the arguments to make sure that we have gotten at least two arguments- one operator and at least one number. If we’ve gotten the right number of arguments, then we need to check that the first argument is an operator that we know how to handle. If it is, we return a function that applies that operator to the remainder of our inputs. Otherwise, we return Nothing.

You’ll notice that we’re using the foldl1 function for subtraction and division. This is a useful helper function that behaves similarly to foldl, but it uses the first element of the list as the starting accumulator value.

Once we know that we’ve got a valid operator, the last step is to convert the remainder of our inputs to numbers, and then apply our operator. Let’s load this up in ghci and see how it works:

-- Normal Operations
λ withArgs ["+", "1", "2", "3"] runCalculator
6
λ withArgs ["-", "5", "1", "1"] runCalculator
3
λ withArgs ["*", "2", "3", "5"] runCalculator
30
λ withArgs ["/", "1024", "2", "2", "2"] runCalculator
128

-- Insufficient Arguments
λ withArgs [] runCalculator
Missing arg(s). Need an operator and at least 1 number
λ withArgs ["+"] runCalculator
Missing arg(s). Need an operator and at least 1 number

-- Invalid operator
λ withArgs ["^", "2", "3"] runCalculator
^ - Unrecognized Operator. Please use one of +,*,-,/

Later on in the book, you’ll learn some ways to handle errors more effectively, and with less verbosity.

As you saw in the previous exercise, writing programs that use command line arguments and deal with files can introduce a lot of additional error handling that can detract from the core problem that we’re trying to solve. This time, let’s focus on solving our problem without the extra error the handing.

We’ll need to work with three different command line arguments for this program. Let’s start by creating a new record to hold our configuration data:

data Config = Config
  { configInputFile :: FilePath
  , configNeedle :: String
  , configReplacement :: String
  }

Next, let’s create a new IO action that will get the command line arguments and use them to generate a Config record:

getConfig :: IO Config
getConfig = do
  [path, needle, replacement] <- getArgs
  return $ Config path needle replacement

Now that we have a config, let’s create another IO action to handle reading a file and replacing the contents based on the current configuration. We’d like to keep the pure code separate from the code with side effects, so we’ll call a not-yet-written function named replaceTargetInDocument that will do the actual work of replacing the text. We’ll implement that function soon, for now we’ll create a placeholder and leave it undefined.

replaceTargetInDocument :: String -> String -> String -> String
replaceTargetInDocument = undefined

runConfig :: Config -> IO String
runConfig (Config path needle replacement) = do
  document <- readFile path
  return $ replaceTargetInDocument needle replacement document

Although runConfig does most of the heavy lifting, we’ll still need a main function to get the config, pass it into runConfig, and finally to print out the results. Thanks to the way we’ve written these functions, we can easily combine them with (>>):

main :: IO ()
main = getConfig >>= runConfig >>= putStrLn

We’re getting close to a solution, but we still haven’t can’t quite test this. Since we haven’t defined replaceTargetInDocument, any attempt to test our program will crash:

λ withArgs ["/tmp/poem.txt", "George", "Echo"] main
*** Exception: Prelude.undefined
CallStack (from HasCallStack):
  error, called at libraries/base/GHC/Err.hs:74:14 in base:GHC.Err
  undefined, called at WordReplacement.hs:16:27 in solution-code-0-inplace:EffectiveHaskell.Exercises.Chapter7.WordReplacement

Let’s finish the last bit of our program and then try again. We need to define replaceTargetInDocument. This function will be responsible for replacing every occurrence of the needle in a document with the replacement:

replaceTargetInDocument :: String -> String -> String -> String
replaceTargetInDocument needle replacement =
  unwords . map replaceTargetWith . words
  where
    replaceTargetWith input
      | needle == input = replacement
      | otherwise = input

This function works by first taking the full document and converting it to a list of individual words using the words function from Prelude. Next, for each individual word, we check to see if the word matches needle and, if so, replace it with replacement. Finally, we re-combine all of the post-replacement words into a single string with the unwords function.

With this last function defined, we can test our new program. Let’s give it a try with a short poem:

Once was a parrot, George by name,
Who played a quite unusual game.
A fervent coder, to our surprise,
In love with Haskell’s neat disguise.

“Good day,” George squawks, takes his stance,
In lines of Haskell code, he’d dance.
From loops to functions, night and day,
In data types, George would play.

George wasn’t your typical bird,
His love for code, it was absurd.
“Skip the cracker, bring me scripts,
Watch my joy in coding flips!”

George, oh George, so bright and clever,
In the world of bugs, he’d never waver.
His playground wasn’t skies or trees,
But the logic of his machine’s keys.

“Give me Haskell,” cries George in glee,
His feathers twitching with pure spree.
The joy of coding he implores,
Syntax sugar, he adores.

So here’s to George, with his might,
Coding Haskell, day and night.
Remember him when you hear a squawk,
It’s George the Parrot, in code talk.

Let’s use our new program to try to replace George with Echo in the body of our poem:

user@host:~WordReplacement$ ghc WordReplacement.hs
user@host:~WordReplacement$ ./WordReplacement ./poem.txt George Echo
Once was a parrot, Echo by name, Who played a quite unusual game. A fervent
coder, to our surprise, In love with Haskell's neat disguise. "Good day," Echo
squawks, takes his stance, In lines of Haskell code, he'd dance. From loops to
functions, night and day, In data types, Echo would play. Echo wasn't your
typical bird, His love for code, it was absurd. "Skip the cracker, bring me
scripts, Watch my joy in coding flips!" George, oh George, so bright and clever,
In the world of bugs, he'd never waver. His playground wasn't skies or trees,
But the logic of his machine's keys. "Give me Haskell," cries Echo in glee, His
feathers twitching with pure spree. The joy of coding he implores, Syntax sugar,
he adores. So here's to George, with his might, Coding Haskell, day and
night. Remember him when you hear a squawk, It's Echo the Parrot, in code talk.

Our program seems to be working pretty well, but our use of words and unwords is causing us to lose newlines. Perfectly preserving formatting can turn into a pretty complicated problem if we want to address all possible edge cases, but let’s take one more pass at a slightly more robust implementation of our program. In our new version, we’ll first split our program into lines, then split each line into words. We’ll lose extra spacing between words, but we’ll still be able to preserve newlines:

replaceTargetInDocument :: String -> String -> String -> String
replaceTargetInDocument needle replacement =
  unlines . map replaceInLine . lines
  where
    replaceInLine = unwords . map replaceTargetWith . words
    replaceTargetWith input
      | needle == input = replacement
      | otherwise = input

As you can see, we only need to make a couple of minor changes to replaceTargetInDocument to add support for retaining empty lines. Instead of immediately breaking the entire document into words and calling replaceTargetWith, we first break our document into lines. We take the same approach for each line that we originally took for the whole document: break the line into words, apply replaceTargetWith to each word, then rejoin the docment. Let’s try it out:

user@host:~WordReplacement$ ghc WordReplacement.hs
user@host:~WordReplacement$ ./WordReplacement ./poem.txt George Echo
Once was a parrot, Echo by name,
Who played a quite unusual game.
A fervent coder, to our surprise,
In love with Haskell's neat disguise.

"Good day," Echo squawks, takes his stance,
In lines of Haskell code, he'd dance.
From loops to functions, night and day,
In data types, Echo would play.

Echo wasn't your typical bird,
His love for code, it was absurd.
"Skip the cracker, bring me scripts,
Watch my joy in coding flips!"

George, oh George, so bright and clever,
In the world of bugs, he'd never waver.
His playground wasn't skies or trees,
But the logic of his machine's keys.

"Give me Haskell," cries Echo in glee,
His feathers twitching with pure spree.
The joy of coding he implores,
Syntax sugar, he adores.

So here's to George, with his might,
Coding Haskell, day and night.
Remember him when you hear a squawk,
It's Echo the Parrot, in code talk.