Fast Haskell Parser

[John D. Earle]

I was thinking of ways to create an efficient Haskell parser. My initial 
thinking was to write a top down parser in Haskell, but if you want speed a 
table driven approach may make greater sense.

Due to the existence of build bots there is a certain degree of compliancy 
concerning build times. I feel that convenience is an important factor. It 
should be convenient to build the source. Build bots make an assumption, 
namely the existence of a formal infrastructure. I believe that it should be 
possible to build something from source casually.

This is a less demanding goal than high performance incremental builds. It 
would be nice to out perform make files because if you fail to do this, can 
it really be said that you are making progress? Correctness appears to be a 
low priority among computer programmers. That said, it may be worth 
investing some time in advance to figuring out how to best achieve both 
objectives, namely correctness and performance. Who knows skills acquired in 
one project may be useful in another and performance is usually welcome.

So my question is, What sort of tools and methodologies exist in Haskell to 
create high performance parsers? My impression is the speed at which the 
parser performs its task is not the bottle-neck, but the parser might as 
well be designed to be efficient so as not to be intellectually lazy. It may 
even turn out that the parser may need to be efficient merely to compensate 
for the spawn of correctness, namely slow builds.