Interaction and ambiguous type variables

Dear all,

I am posting the following bug report every once in a while.
It describes a recurring and annoying problem (which I call
bug). It's annoying for beginners and students and it's
annoying for instructors, as well.

Here we go (using Hugs all along, but ghci is not that different).

------------------------------------------------------------------------------

<< Instructor:
implement `mirror' (aka reverse).

<< Student:

> mirror :: [a] -> [a]
> mirror [] = []
> mirror (a : as) = mirror as ++ [a]

But, I have a problem: the program does not work.

Main> mirror []
ERROR - Cannot find "show" function for:
*** Expression : mirror []
*** Of type    : [a]

<< Instructor:
it's because `mirror []' has the polymorphic type `[a]' and the
compiler cannot determine the `Show' instance for `a'. You can
find further explanations at
	http://www.cs.ukc.ac.uk/people/staff/sjt/craft2e/errors.html
[All this is jolly difficult to explain in the first week of
a Haskell course. It's annyoing because the result is, of course, the
empty list. Yes, I know that the empty list can be printed in
different ways depending on the type:
Main> mirror [] :: [Int]
[]
Main> mirror [] :: String
""
Alas, I don't think this justifies the trouble.]

<< Instructor:
implement `turn' (aka mirror or reverse) on trees.

<< Student:

> data Tree a = Empty | Node (Tree a) a (Tree a)
>               deriving (Show)

> turn :: Tree a -> Tree a
> turn Empty = Empty
> turn (Node l a r) = Node (turn r) a (turn l)

But, I have a problem: the program does not work.
Main> turn Empty
ERROR - Cannot find "show" function for:
*** Expression : turn Empty
*** Of type    : Tree a

<< Instructor:
<see above>
[Now, the result is obvious and there is only one way to print it!
Yes, I know that we can complicate matters slightly so that the
result is again ambiguous in print.
Main> turn (Node Empty [] Empty)
ERROR - Cannot find "show" function for:
*** Expression : turn (Node Empty [] Empty)
*** Of type    : Tree [a]

Main> turn (Node Empty [] Empty) :: Tree [Int]
Node Empty [] Empty
Main> turn (Node Empty [] Empty) :: Tree String
Node Empty "" Empty

Again, it's only the empty list that may come out in different
shapes. But, things still can get worse.]

<< Instructor:

implement a test that checks whether a list is ordered.

<< Student:

> ordered :: (Ord a) => [a] -> Bool
> ordered [] = True
> ordered [a] = True
> ordered (a : b : as) | a <= b    = ordered (b : as)
>                      | otherwise = False

But, I have a problem: the program does not work.
Main> ordered []
ERROR - Unresolved overloading
*** Type       : Ord a => Bool
*** Expression : ordered []

<< Instructor:
<see above>
[Now, we have not even a problem of ambiguity. The expression is not
ambiguous.]

------------------------------------------------------------------------------

The general problem is that the expression submitted to Hugs or GHC has a
polymorphic type *or* that a subexpression has a polymorphic type (as
in the last example). A simple solution is to monomorphize the type
instantiating all type variables to, say, the empty type `Void'.
Additionally, we have to add instances for the standard classes 

instance Show Void
instance Eq Void

etc.

Why do we need instances for all the classes? If a subexpression has
a polymorphic type, then other classes may be affected.
Main> [] == []
ERROR - Unresolved overloading
*** Type       : Eq a => Bool
*** Expression : [] == []

------------------------------------------------------------------------------

Let me close by saying that I think it's important to address this
problem because it bites students again and again and again ...

Cheers, Ralf