I’m not sure that I agree that languages like Haskell are the best for compiler writing. But then again, my project (which I intend to be very very good at it) is still partially vapor, so I can’t make any grandiose claims about being better than Haskell in this problem domain. Yet.

But for your second point, you seem to be missing the N^2 vs. N+N argument I was trying to make. Sure, of course you can write bindings. I’ll ignore for a moment the practical matters of what it means to embed Haskell into your process and just assume that bindings are a practical and compelling solution.

Even if I grant you that, writing bindings for each language pair that you want to parse from/to is madness! It takes N^2 work. If you do things my way, you have to write:

- a parser for C
- a parser for Haskell
- a parser for JavaScript
- Gazelle bindings for C
- Gazelle bindings for Haskell
- Gazelle bindings for JavaScript

At that point, I can parse Haskell from JavaScript, or C from Haskell, or any of the N^2 combinations, but it only took me N+N work. If I do things your way, to get the same functionality, I have to write:

- a parser for C
- a parser for Haskell
- a parser for JavaScript
- C bindings for the C parser
- C bindings for the Haskell parser
- C bindings for the JavaScript parser
- Haskell bindings for the C parser
- Haskell bindings for the Haskell parser
- Haskell bindings for the JavaScript parser
- JavaScript bindings for the C parser
- JavaScript bindings for the Haskell parser
- JavaScript bindings for the JavaScript parser.

Bindings aren’t trivial. So at the end of the day, since no one is actually going to do the N^2 work, the Language.C person will say “sure, you can use my library, all you have to do is write bindings!” and the person will decide that bindings are too much work for the return you get (because they are), or they’ll be partially written and sporadically maintained bindings that aren’t useful to anyone else, and we’ll keep having the fragmented parser landscape we have today.

Or I’ll finish Gazelle and that pain will be a thing of the past.

That said, Haskell’s perfectly interoperable with C, or Python, or
anything that understands the C calling convention, so you could just
bind to Language.C from other languages (much as others bind to CIL, yet
another C parser/analyser, this time in OCaml).