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:<p><pre><code>  func = undefined --TODO: implement func
</code></pre>
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&#x27;t have to care about the fact that it&#x27;s not yet defined.  This lets you verify that the rest of your program still compiles properly, for example.<p>This means that preserving the lazy evaluation of undefined expressions matters.  For example, it&#x27;s perfectly OK to do this in ghci:<p><pre><code>  Prelude&gt; let myfunc = undefined::(Integer -&gt; Integer)
  Prelude&gt; let ints = [1, 2, 3]
  Prelude&gt; let results = map myfunc ints
  Prelude&gt; let square x = x * x
  Prelude&gt; let results_squared = map square results
</code></pre>
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&#x27;ll get an error:<p>Prelude&gt; results_squared
[<i></i>* Exception: Prelude.undefined<p>But it matters that this only happens when I actually force the computation somehow.