Type-level operators

[Stefan Holdermans]

Simon,

Regarding the note you attached to the Trac ticket on the pretty-printing of kind ascriptions (http://hackage.haskell.org/trac/ghc/ticket/5141#comment:2):

> Note, though, that it's likely that we're considering making operators
> like '*' into type ''constructors'' rather that type ''variables'.  This
> is inconsitent with terms, but is jolly convenient:
> {{{
> data a + b = Left a | Right b
> }}}
> Of course there'll be a flag.  But let us know if you think that having
> operators be type variables is very useful.  (I tend to think it's more
> confusing than useful.)

I myself am perfectly alright with being "forced" to write

{{{
data a :+: b = Left a | Right b
}}}

Although I don't have a *convincing* example of the usefulness of operators as type variables, I like the idea of consistency with the term level: IMO it keeps things predictable.

And even as it may not qualify as convincing, I do remember having written code similar to

{{{
data (f :+: g) a = Inl (f a) | Inr (g a)
data (f :*: g) a = f a :*: g a

class FunctorOp ((&) :: (* -> *) -> (* -> *) -> (* -> *)) where ...
instance FunctorOp (:+:) where ...
instance FunctorOp (:*:) where ...

class FunctorOp (&) => CommOp (&) where comm :: f & g -> g & f
instance CommOp (:+:) where ...
instance CommOp (:*:) where ...

f :: (CommOp (&), Functor f, Functor g) -> f & g -> ...
f ... = ...
}}}

All this, of course, just to put in my tuppence worth.

Cheers,

  Stefan