How do I use a guard with putStrLn?

Question

I'm trying to write a function that will execute 2 different game modes which are defined as tictactoe :: IO () and main :: IO (). I'm getting a parse error on input '|'. I don't understand what I am doing wrong. Could someone please explain this to me?

tictac :: IO()
tictac = do 
       putStrLn "Would you like to play against the computer or 
                 another player? Enter: 2 Player or Computer"
       choice <- getLine
         |choice == "Computer" = main
         |choice == "2 Player" = tictactoe
         |otherwise = putStrLn "That's not a choice!"

Answer 1

There's a limited set of places where you can use guards - they're most commonly used only in function definitions. In this situation you're probably looking for the case statement instead:

choice <- getLine
case choice of
     "Computer" -> main
     "2 Player" -> tictactoe
      _         -> putStrLn "That's not a choice!"

^{The _ pattern matches anything, which "mops up" the leftover patterns. Its use here is analogous to otherwise, although otherwise is actually just syntactic sugar for true given that the expressions in guards are boolean.}

It's not quite the same as guards, as guards evaluate boolean expressions while case does pattern matching, but it works. A more accurate dual of guards would be if expressions, but the case syntax is nicer when you can use it instead. Take a look at the control structures page on the wiki for more examples.

---

As pointed out in the comments, it's possible to use guards in case expressions as well - you can see this in the specification and in this question/answer. It does require at least one pattern match though, which is ugly here - you could use the "hack" described here to do something like:

case () of
 _ | choice == "Computer" -> main
   | choice == "2 Player" -> tictactoe
   | otherwise            -> putStrLn "That's not a choice!"

But here there's no advantage to doing so.

Answer 2

There are a few ways to test values like this, but the way that’s most similar to what you’ve written is to use the extension called MultiWayIf, available since GHC 7.6 (September 2012). Add the pragma:

{-# LANGUAGE MultiWayIf #-}

To the top of your source file (or use :set -XMultiWayIf in GHCi) and you can write the following:

choice <- getLine
-- Simply add the ‘if’ keyword here.
if
  | choice == "Computer" -> main
  | choice == "2 Player" -> tictactoe
  | otherwise -> putStrLn "That's not a choice!"

Ordinarily, guard syntax | condition only works in two places: in definitions (where a guard goes after the name & arguments, before the = symbol) and in case (where it goes after the pattern, before the -> symbol):

doubleIfEven :: Int -> Int
-- Definition
doubleIfEven x
  | even x = x * 2
  --------
  | otherwise = x
  -----------

doubleIfJustEven :: Maybe Int -> Maybe Int
doubleIfJustEven mx
  -- Match
  = case mx of
    Just x
      | even x -> Just (x * 2)
      --------
      | otherwise -> Just x
      -----------
    Nothing -> Nothing

---

Here are the alternatives:

1. case expressions, in this case where you’re only testing for (structural) equality on strings:

   case choice of
     "Computer" -> main
     "2 Player" -> tictactoe
     _ -> putStrLn "That's not a choice!"
   

2. A local definition in a where clause or let binding:

   tictac :: IO ()
   tictac = do 
     putStrLn "Would you like to play against the computer or\
              \ another player? Enter: 2 Player or Computer"
     choice <- getLine
     check choice
   
     where
       check choice
         | choice == "Computer" = main
         | choice == "2 Player" = tictactoe
         | otherwise = putStrLn "That's not a choice!"
   
   ----
   
   tictac :: IO ()
   tictac = do 
     putStrLn "Would you like to play against the computer or\
              \ another player? Enter: 2 Player or Computer"
     let
       check choice
         | choice == "Computer" = main
         | choice == "2 Player" = tictactoe
         | otherwise = putStrLn "That's not a choice!"
     choice <- getLine
     check choice
   

3. Nested if expressions:

   if choice == "Computer" then main
     else if choice == "2 Player" then tictactoe
     else putStrLn "That's not a choice!"
   

4. case with a dummy pattern and guards (an old idiom):

   case () of
     _ | choice == "Computer" -> main
       | choice == "2 Player" -> tictactoe
       | otherwise -> putStrLn "That's not a choice!"
   

#1 is most common for matching; #2 is used if you need guards and either want to avoid MultiWayIf to support old compilers, or simply want to factor out the logic into a separate definition for readability; #3 and #4 aren’t very common or idiomatic, but there’s nothing “wrong” with them.