Do Syntax – Haskell

In Haskell, the do syntax provides a way to write sequential operations in a style that looks imperative, even though Haskell is a purely functional language. This syntax is particularly useful when working with monads, as it allows you to chain actions in a readable and manageable way. The do notation simplifies code by allowing monadic operations to be expressed in a linear, step-by-step manner, especially helpful for handling side effects, chaining computations, and managing contexts like Maybe, IO, and Either.

This article will explain what the do syntax is, how it works, and when to use it in Haskell programming.

What is the do Syntax?

The do syntax is syntactic sugar in Haskell for sequencing monadic operations. Monads allow us to structure computations that involve a sequence of dependent steps, where each step is executed within a specific context. The do syntax simplifies monadic operations, making it easier to express them in a way that looks like traditional step-by-step programming.

Without do notation, monadic operations are typically written using the >>= (bind) operator. This approach can be verbose and harder to read when chaining multiple operations. The do syntax, however, hides the bind operator, letting you write code that reads almost like pseudocode.

Basic Example of do Syntax

Consider a simple example in the IO monad, which is commonly used for input and output operations in Haskell. Here’s a basic program that reads a name from the user and then greets them:

main :: IO ()
main = do
    putStrLn "What is your name?"
    name <- getLine
    putStrLn ("Hello, " ++ name ++ "!")

In this example:

1. putStrLn "What is your name?" outputs a prompt to the user.
2. name <- getLine reads input from the user and binds it to the variable name.
3. putStrLn ("Hello, " ++ name ++ "!") uses the name in a greeting.

The do notation lets us write each line as if we were writing imperative code, where each action happens one after the other.

How do Syntax Works Behind the Scenes

Under the hood, do notation is converted into a series of bind (>>=) operations by the compiler. Here’s what our example above would look like without do notation:

main :: IO ()
main =
    putStrLn "What is your name?" >>= \_ ->
    getLine >>= \name ->
    putStrLn ("Hello, " ++ name ++ "!")

This code does the same thing as the do version but is more challenging to read. The do syntax abstracts away the chaining of >>= operations, making the code easier to follow.

Binding Values with <-

In do notation, <- is used to extract a value from within a monadic context and bind it to a variable. This is particularly useful when dealing with Maybe, IO, or Either types, as it lets us work directly with the values inside these contexts.

Example with Maybe

The Maybe monad is used to represent computations that may fail. Here’s an example that adds two Maybe Int values using do notation:

addMaybe :: Maybe Int -> Maybe Int -> Maybe Int
addMaybe mx my = do
    x <- mx
    y <- my
    return (x + y)

Here’s how it works:

1. x <- mx extracts the value from mx if it’s Just and binds it to x. If mx is Nothing, the whole expression evaluates to Nothing, and the rest of the code is skipped.
2. y <- my works similarly, binding y to the value in my.
3. return (x + y) wraps the sum of x and y in a Maybe context (Just), which becomes the result.

Without do notation, this function would look like:

addMaybe :: Maybe Int -> Maybe Int -> Maybe Int
addMaybe mx my =
    mx >>= \x ->
    my >>= \y ->
    return (x + y)

do Syntax in Other Monads

The do syntax isn’t limited to IO and Maybe. It can be used with any monad, including Either for error handling, lists for nondeterministic computations, and custom monads.

Example with Either

The Either monad is often used to represent computations that can fail with an error. Here’s an example that uses Either to handle division with error checking:

safeDivide :: Int -> Int -> Either String Int
safeDivide _ 0 = Left "Division by zero"
safeDivide x y = Right (x `div` y)

calculate :: Int -> Int -> Int -> Either String Int
calculate a b c = do
    x <- safeDivide a b
    y <- safeDivide a c
    return (x + y)

In this example:

1. x <- safeDivide a b performs the first division. If b is zero, safeDivide will return Left "Division by zero", and the rest of the do block is skipped.
2. y <- safeDivide a c performs the second division under similar conditions.
3. return (x + y) returns the sum of x and y in an Either context.

The do syntax here makes error handling with Either much more straightforward.

Using do for Pure Code: Maybe Example

In Haskell, do notation can even be used for pure computations when working with monads like Maybe. This allows you to handle computations that may fail without needing any external effects.

Consider a lookup function that tries to find a value in a map, where the lookup might fail:

import qualified Data.Map as Map

lookupBoth :: Ord k => k -> k -> Map.Map k v -> Maybe (v, v)
lookupBoth k1 k2 m = do
    v1 <- Map.lookup k1 m
    v2 <- Map.lookup k2 m
    return (v1, v2)

Here, lookupBoth will return Nothing if either k1 or k2 is not found in the map; otherwise, it returns Just (v1, v2), where v1 and v2 are the values associated with k1 and k2.

Mixing do with let and return

Inside a do block, you can use let to define local bindings without extracting from a monadic context, and return to wrap a value back into the monad:

main :: IO ()
main = do
    let greeting = "Hello"
    name <- getLine
    return (greeting ++ ", " ++ name ++ "!")

• let: Creates a local binding without the need for <-.
• return: Wraps a value back into the monadic context (e.g., IO, Maybe).

When to Use do Syntax

The do syntax is beneficial in the following situations:

1. Sequencing Dependent Computations: When each step relies on the results of previous computations within a monad.
2. Working with Monadic Values: Whenever you need to operate on values in a monadic context like Maybe, Either, or IO.
3. Readable Code: To improve readability when chaining multiple monadic operations, especially for IO actions, error handling, or chaining computations.

Summary

The do syntax in Haskell provides a way to write readable and linear code for monadic operations, turning complex chains of computations into clean, sequential blocks. It works by hiding the >>= (bind) operator and allowing us to handle monadic values with <-, making it especially useful when working with contexts like IO, Maybe, Either, and more.

By understanding do notation, you unlock a powerful tool for managing effects, handling optional or error-prone computations, and creating clean, maintainable code in Haskell’s functional paradigm. This syntax not only simplifies complex monadic expressions but also keeps Haskell code expressive and elegant.