I wrote a Haskell program that preforms a binary search on a list. At least that's what I thought it does. When I compiled the program with ghc v7.6.3 and ran the program I got the following output: 

progname: <>

What on earth does this output mean? Does it mean I had an infinite loop that ghc optimized away? How am I supposed to debug this?

Answer:

As several of the comments have said, this is the Haskell RTS detecting an infinite loop at run-time. It cannot always detect such loops, but in simple cases it can.

For example, 

x = x + 1

will compile just fine, but provoke an exception at run-time. (Incidentally, this is an exception - in particular, you can catch it if you want. But you probably don't "want".)

So why does GHC even let this compile? Well, because if I replace + with, say, :, then the expression now terminates just fine. (It represents a 1-element circular list.) The compiler can't tell at compile-time what is and is not sensible recursion. The RTS can't always tell at run-time; but when it can tell something's wrong, it'll let you know by throwing an exception at you. 

In Haskell, the <<loop>> error is caused by an infinite loop in the program, where the program enters an infinite recursion and cannot terminate. This error occurs when Haskell detects that the program is not making any progress towards completing its task and is stuck in an infinite loop.

For example, consider the following Haskell program that calculates the factorial of a number: 

factorial n = if n == 0 then 1 else n * factorial (n - 1)

This program recursively calls itself with decreasing values of n until n becomes 0. However, if n is negative, the program will enter an infinite recursion, repeatedly calling factorial with a negative argument and never terminating.

To fix this issue, you can add a check to ensure that n is non-negative before calling factorial: 

factorial n = if n < 0 then error "n must be non-negative" else if n == 0 then 1 else n * factorial (n - 1)

This way, if n is negative, the program will throw an error instead of entering an infinite recursion.