My problem with cucumber is not the idea of a high-level DSL for tests. Au contraire--I think this is a perfect place for a little language. I could easily see a similar tool being useful for Haskell.

Rather, my issue is with the syntax. Not gherkin in particular but rather languages that try to look like English in general. For one, these languages tend to hit the uncanny valley--they're somewhat natural, but not entirely. Perhaps the code reads like poorly written prose, but you certainly can't write it in a natural fashion!

More importantly, I do not think prose is a good format for this sort of thing at all. It's good for reading code, but I almost never read code directly. Instead, I usually look over large parts of code at a time. I want code where I can get the structure at a glance and easily separate the parts that are specific to the current application from ones that aren't. With prose-like syntax, this is very difficult because everything is made of words. That programming language syntax you dismiss as line noise? It's actually the structure of the code, which makes it much *faster* to read!

There's a reason mathematicians user equations and diagrams so much. A single equation can replace literally pages of text, and you can have a pretty good idea of what's going on without having to look too closely at all the details. Think about an integral, for example: from the equation, you can easily see what sort of equation it is (trigonometric, polynomial, exponential...), what domain you're integrating over, what the limits are and, very importantly, that it *is* an integral rather than something completely different. All just from what the equation looks like, before you've had to expend much attention on it.

One way to think about it is that the notation factors out the repeated parts of an integral so that it's easy to visually separate from the "meat"--the function you're actually integrating. A good DSL uses symbols to do the same thing.

The main cost, of course, is that you have to learn the notation. But this is really a one-time cost; if you're going to be seeing a lot of integrals, it's more than worth doing, especially because there's so much shared structure between them. Similarly, it's worth doing for tests, for the same reasons. There's a lot of shared structure--just look at how many relatively long phrases got repeated even in the simple examples given here--and you want to look over that structure without actually reading it. Much easier with actual syntax than prose. In any real app, you will have hundreds of tests, and learning to deal with the "line noise" gets amortized over all of them, whereas the benefits (shorter code that's easier to scan) scale at least linearly.

So I think we should really avoid the faux-natural-language syntax as much as possible.