Understanding Type of IO () in `let` Expression

Question

Given:

λ: let f = putStrLn "foo" in 42
42

What is f's type? Why does "foo" not get printed before showing the result of 42?

Lastly, why doesn't the following work?

λ: :t f

<interactive>:1:1: Not in scope: ‘f’

Answer 1

What is f's type?

As you have correctly identified, it is IO () which can be thought of as an IO action that returns nothing useful (())

Why does "foo" not get printed before showing the result of 42?

Haskell is lazily evaluated, but even seq is not enough in this case. An IO action will only be performed in the REPL if the expression returns the IO action. An IO action will only be performed in a program if it's returned by main. However, there are ways to get around this limitation.

Lastly, why doesn't the following work?

Haskell's let names a value within the scope of an expression, so after the expression has been evaluated f goes out of scope.

Answer 2

let f = ... simply defines f, and does not "run" anything. It is vaguely similar to a definition of a new function in imperative programming.

Your full code let f = putStrLn "foo" in 42 could be loosely translated to

{
  function f() {
     print("foo");
  }
  return 42;
}

You wouldn't expect the above to print anything, right?

By comparison, let f = putStrLn "foo" in do f; f; return 42 is similar to

{
  function f() {
     print("foo");
  }
  f();
  f();
  return 42;
}

The correspondence is not perfect, but hopefully you get the idea.