Return – Haskell

For newcomers to Haskell, the return function can be confusing, especially for those transitioning from imperative programming languages where return is used to exit a function and provide a result. In Haskell, return means something entirely different. It’s a fundamental concept in monadic programming, and understanding its role is key to mastering Haskell.

This article explores what return means in Haskell, how it’s used, and how it differs from the return you might know in other programming paradigms.

What is return in Haskell?

In Haskell, return is a function that takes a value and wraps it in a monad. It doesn’t exit a function or terminate execution like in imperative languages. Instead, it creates a monadic value, making it possible to work within a monadic context.

Type Signature

The type signature of return is:

return :: Monad m => a -> m a

This means:

• It takes a value of type a.
• It returns a value of type m a, where m is any monad (e.g., Maybe, IO, [], etc.).

How return Works in Different Monads

1. In the IO Monad

The IO monad is used to handle input/output in Haskell. return in this context wraps a value into an IO action.

Example:

main :: IO ()
main = do
  action <- return "Hello, World!"
  putStrLn action

What’s Happening?

• return "Hello, World!" wraps the string "Hello, World!" in an IO monad.
• It doesn’t execute anything; it simply creates an IO action that produces the string when executed.

2. In the Maybe Monad

The Maybe monad is used to represent computations that might fail. return wraps a value into a Just, representing a successful computation.

Example:

example :: Maybe String
example = return "Success!"

What’s Happening?

• return "Success!" creates a Just "Success!".
• It’s equivalent to writing Just "Success!" directly, but return emphasizes working in a monadic context.

3. In the List Monad

The list monad represents nondeterministic computations. return wraps a single value into a list.

Example:

example :: [Int]
example = return 42

What’s Happening?

• return 42 creates the list [42], a single-item list.
• It’s equivalent to writing [42] directly.

Key Points About return

1. It Doesn’t Exit a Function
   • Unlike return in imperative languages, Haskell’s return does not end or exit a function. It’s purely about wrapping values in a monadic context.
2. It’s Not Special
   • return is just a regular function defined as part of the Monad type class. It’s not a keyword or syntactic construct.
3. It’s Context-Dependent
   • The behavior of return depends on the monad being used. In IO, it creates an IO action; in Maybe, it creates a Just; in lists, it creates a singleton list.
4. It’s Often Paired with >>=
   • return works in harmony with the >>= (bind) operator, which chains monadic operations together.

Common Misunderstandings

1. Does return Perform an Action?

No, return does not perform any computation or side effect. It only wraps a value in a monadic context.

Example:

main :: IO ()
main = do
  return "Hello"
  putStrLn "World"

Output:

World

The return "Hello" does nothing visible here because it simply wraps the value "Hello" in an IO monad, but that monad isn’t used or executed.

2. Is return Needed to Return a Value?

Not always. In many cases, you can directly construct monadic values (e.g., using Just, [x], or pure).

Example Without return:

example :: Maybe String
example = Just "Success!"

return is used primarily to signal intent in monadic contexts, making it clear that a value is being lifted into the monad.

The Relationship Between return and pure

In Haskell, pure is a more general function defined in the Applicative type class, which is a superclass of Monad. For monads, return and pure are interchangeable.

Type Signature of pure

pure :: Applicative f => a -> f a

For most monads, return is implemented as an alias for pure.

Example:

example1 = return 42  -- Works in Monad
example2 = pure 42    -- Works in Applicative

Both example1 and example2 will behave identically in monads like Maybe or IO.

Using return in Real-World Code

Example: Combining return with do Notation

return is commonly used in do notation to create monadic values.

Example:

greet :: String -> IO String
greet name = do
  let greeting = "Hello, " ++ name
  return greeting

main :: IO ()
main = do
  message <- greet "Alice"
  putStrLn message

Output:

Hello, Alice

Here:

• return greeting wraps the String in an IO monad so it can be used in the do block.

When to Avoid return

You don’t need return to write all monadic code. It’s often redundant if you can directly produce monadic values.

Example:

Instead of:

example :: Maybe Int
example = return 42

You can simply write:

example :: Maybe Int
example = Just 42

Conclusion

In Haskell, return is a monadic function that wraps values into a monad. It is not the same as return in imperative languages and does not exit functions or perform computations. Instead, it ensures values work within the context of monadic operations. Understanding return helps clarify how Haskell handles side effects, computations, and context in a purely functional way.