You can transform your method calls into sentences by separating parameters into their own functions. Your method calls would be as close as possible to a real sentence if it weren’t for the problem of this darn syntax, where all the inputs need to be listed at the end of the sentence. What if you could mention the inputs anywhere in the sentence? It would be so much like prose.
Take an example from a Javascript implementation of the Game of Life that I recently wrote. My friend Sam and I discovered that, with a little work, this:
|
1 2 |
/** A whole bunch of documentation explaining what this means. */ testCellTransition(3, DEAD, ALIVE); |
can become this:
|
1 2 |
/** No documentation needed. */ testThat().CellStarting(DEAD).TransitionsTo(ALIVE).WithNeighbors(3); |
The hell?! How does that become this?! Here’s how:
Original:
|
1 2 3 4 |
void testCellTransition(int neighbors, State currentState, State expectedTransitionState) { Cell cell = new Cell(currentState); assertEqual(expectedTransitionState, cell.nextState(neighbors); } |
Improved (maybe):
|
1 2 3 4 5 6 7 8 9 10 |
function testThat() { return function CellStarting(State currentState) { return function TransitionsTo(State expectedTransitionState) { return function WithNeighbors(int neighbors) { Cell cell = new Cell(currentState); assertEqual(expectedTransitionState, cell.nextState(neighbors); } } } } |
It’s sort of like a unit test generator since you can simply test all conditions by inputting all possible permutations of your inputs. But then again, so is the original function. The only real difference is the syntactic cheat (and probably computationally expensive cheat) that allows me to morph the appearance, but not the functionality, of the test. This, of course, only works in certain programming languages, and is only beneficial if readability outweighs performance. Still, pretty cool, if I may say so myself.