superclass implications

[Claus Reinke]

>>>    >   class Monad m => MonadPlus m    if  <..oops..>
>> if Monad m, then declare MonadPlus m as follows..
> 
> This gloss doesn't make sense. The act of declaration is a constant 
> static property of the module, and cannot be conditional on the property 
> of a variable. The module _always_ declares the class.

would be nice, wouldn't it? and since section 4.3.1 "Class Declarations"
skirts the issue, one might assume that it does (*). but if you look through
4.3.2 "Instance Declarations", you'll find:

    1. .. In other words, T must be an instance of each of C's superclasses 
    and the contexts of all superclass instances must be implied by cx'. 

and

    If the two instance declarations instead read like this: 
    ...
    then the program would be invalid. 

in other words, whether or not the superclass instances exist does not
just affect whether or not the subclass instances exist, it affects whether
or not the instance declaration, and hence the whole program, is valid.
if you don't have any ms for which Monad m holds, you won't be able
to declare any instances of MonadPlus m.

it doesn't matter whether you never use those instances. this program 
is simply not valid (but adding an A Int instance makes so):

    class A x
    class A x => B x 
    instance B Int 

(*) granted, the class declaration alone might still be considered valid, 
but you couldn't actually use it for anything, so I'm not sure that makes 
a difference. and whether or not the instance declaration is statically 
valid _is_ conditional on the existence of other instances.

it is this early/eager checking of superclass constraints that I find odd,
and different from all other constraint handling. it means that I can't use
superclass constraints to lift out common method constraints, because

    class <ctxt> => B x where {m1 :: <t1>;..; mn :: <tn>}

is not equivalent to 

    class B x where {m1 :: <ctxt> => <t1>;..; mn :: <ctxt> => <tn>}

[even if the conditions for variables in contexts would not rule that out]
whereas such lifting is possible for common constraints in instances.

it also means that I have to provide superclass instances at the _point
of declaration_ of subclass instances - I can not defer that obligation
to the _point of use_.

cheers,
claus