Hacky Haskell monadic testing
Firstly, I would advise you to look at how blaze-html implements their monads for HTML templating. They are doing something very similar to what you want to do.

You can simplify your definitions a bit by removing the second field from the LeftList constructor:

data LeftList a r = LeftList [a]


Then every place where you use the constructor LeftList you can omit the (now) extraneous (), e.g. the &gt;&gt; definition simplifies to:

  (LeftList xs) &gt;&gt; (LeftList ys) = LeftList (xs ++ ys)


You should also make group, describe, and toTests more general by using a type variable instead of ():

group :: String -&gt; LeftList H.Test r -&gt; LeftList H.Test r


This makes these functions valid for any return type r - not just ().
Of course, you don't care what the return type is anyway. But GHC cares - and allowing a general return type might help with type checking.

It actually is possible to define bind for the LeftList monad -- just pass in undefined or error "...":

  (&gt;&gt;=) (LeftList xs) f = let LeftList ys = f (error "LeftList does not support binding")
                          in LeftList (xs++ys)


An error will occur only if the parameter to f is actually evaluated.

For instance, this will not throw an error:

"foo" ... do
   x &lt;- "with even numbers" ~:
           4 ~=? foo 4
   "with odd numbers" ~:
     0 ~=? foo 5


because the value x is never evaluated.

Finally, with GHC 7.10 you will also have to define Functor and Applicative instances for your monad:

instance Functor (LeftList a) where
  fmap f left = left

instance Applicative (LeftList a) where
  pure _ = LeftList []  -- should be same as return
  (&lt;*&gt;)  = undefined