I've been working on Dr Haskell for a little bit, and its now quite a bit cleverer. For those who don't know, Dr Haskell tries to make helpful suggestions about your code. For example, if you use "concat (map f x)", it will suggest you use "concatMap f x". It can also do other clever things, for example:
not (a == b) ===> use /=
if x `elem` xs then True else x == 1 ===> use an or
if bracket then "(" else "" ===> ['(' | bracket]
The idea is to introduce beginners to new functions or patterns of Haskell that they might not have been aware of, without requiring too much thought or learning, until you have identified such an instance. I think of this as a nice complement to Hoogle, since Hoogle caters for the case when beginners have already identified where a common pattern may lie.
Of course, the biggest weakness in Dr Haskell is that it matches at the expression level only, a beginner might write:
takeheads  = 
takeheads (x:xs) = head x : takeheads xs
(And indeed they do, I've seen that 4 times already today!) An experience programmer would recognise that as a map, and now, so will Dr Haskell! It will report "specialised version of map used as takeheads, line number n".
Some other things that Dr Haskell can now spot:
sum :: [Int] -> Int
sum  = 0
sum (x:xs) = x + sum xs
(its a foldr, as written above - although I realise foldl' is a better choice for sum)
reverse xs = rev  xs
rev acc  = acc
rev acc (x:xs) = rev (x:acc) xs
(rev is a foldl)
Dr Haskell can now spot all of these, and has the power to spot lots more patterns using recursion as well as expression matching. I think this could be really helpful for beginners, if anyone has any interesting ideas about this please let me know. I hope to package up a release in the next few days.