A common practice while working on a Haskell code base is to fill in not-yet-completed functions with `undefined`, which is a divergent expression. This lets you do things like write:
func = undefined --TODO: implement func
and then you can use func in the rest of your code and as long as nothing strictly evaluates the results of func, you don't have to care about the fact that it's not yet defined. This lets you verify that the rest of your program still compiles properly, for example.
This means that preserving the lazy evaluation of undefined expressions matters. For example, it's perfectly OK to do this in ghci:
Prelude> let myfunc = undefined::(Integer -> Integer)
Prelude> let ints = [1, 2, 3]
Prelude> let results = map myfunc ints
Prelude> let square x = x * x
Prelude> let results_squared = map square results
All of this is fine because nothing has actually forced any computation to occur, but I still get the benefits of asserting that my expressions are well-typed. If I actually force evaluation by asking ghci to show a result, I'll get an error:
This means that preserving the lazy evaluation of undefined expressions matters. For example, it's perfectly OK to do this in ghci:
All of this is fine because nothing has actually forced any computation to occur, but I still get the benefits of asserting that my expressions are well-typed. If I actually force evaluation by asking ghci to show a result, I'll get an error:Prelude> results_squared [* Exception: Prelude.undefined
But it matters that this only happens when I actually force the computation somehow.