Haskell中能否在do块返回前检查条件？编译报错求正确写法

Let's start with a common Scala equivalent example first—since you mentioned your logic translates to Scala, I'll use a typical scenario where we read input, check a condition, and return a result:

Scala Equivalent Code #

import scala.io.StdIn
def validateInput(): Unit = {
  val input = StdIn.readLine("Enter a number: ")
  input.toIntOption match {
    case Some(num) => 
      if (num > 10) println("Great, number is big enough!")
      else println("Oops, number is too small.")
    case None => println("That's not a valid integer!")
  }
}

Now, let's break down the common mistakes people make when translating this kind of logic to Haskell do-blocks, and how to fix them.

Common Mistake: Treating if as a Statement #

Haskell doesn't have "statements"—everything is an expression. If you tried writing something like this (mimicking Scala's imperative style), it'll throw a compile error:

import System.IO

validateInput :: IO ()
validateInput = do
  input <- getLine
  let num = readMaybe input :: Maybe Int
  if isJust num && fromJust num > 10
    then putStrLn "Great, number is big enough!"
  -- Missing else branch! This will fail to compile.

Haskell's if requires both branches to exist and return the same type. The compiler can't infer what value to produce when the condition is false, which is why this breaks.

Correct Do-Block Implementation #

Here's the proper Haskell translation that matches the Scala logic:

import System.IO
import Text.Read (readMaybe)

validateInput :: IO ()
validateInput = do
  input <- getLine
  case readMaybe input :: Maybe Int of
    Just num -> 
      if num > 10
        then putStrLn "Great, number is big enough!"
        else putStrLn "Oops, number is too small."
    Nothing -> putStrLn "That's not a valid integer!"

Key Lessons: #

• Never skip the else branch: Since if is an expression, it must evaluate to a value. Skipping a branch leaves the compiler with no valid return value, causing errors.
• Use pattern matching instead of isJust/fromJust: Just like Scala's match, Haskell's case is the idiomatic, safer way to handle types like Maybe in do-blocks. It avoids runtime errors from fromJust and makes code more readable.
• Indentation is critical: Haskell uses indentation to define block structure. Make sure then and else lines are aligned properly under the if to avoid parsing issues.

If you're working with a pure monad like Maybe instead of IO, here's another correct example:

checkPositive :: Int -> Maybe String
checkPositive num = do
  if num > 0
    then return $ "Positive: " ++ show num
    else return "Non-positive number"

Both branches return Maybe String, so the if expression fits seamlessly into the do-block.

内容的提问来源于stack exchange，提问作者heapOverflow