I've been using macros in Clojure to write my own object system. It seems to me that for serious meta-programming in Haskell, you have to use Template Haskell, and from what I've heard, it's not nearly as flexible.

Sure. Consider the case of defining an instance of a type class:

     instance Foo Bar where
         quux = quuxifyBar -- terrible example

Now, you want to follow the same pattern to declare "Foo Baz", "Foo Quux" and "Foo CannedAir". I hope you like copying and pasting, because that's how you do it without Template Haksell.

In Lisp, it would be a simple matter of writing a macro, like this:

    (defmacro make-my-type-thing (type)
         `(instance Foo ,type
              ((quux (x) (,(intern (format nil "quuxify-~A" type)) x)))))

Then you can:

    (eval-when (:compile-toplevel)
        (loop for i in '(Bar Baz Quux CannedAir)
              do (make-my-type-thing i)))

Yes, the example is very contrived, and yes, Haskell ships with a lot of abstractions to make this case very uncommon. But in Haskell, you just can't treat your code as data -- it's code.