Ad-hoc Arbitraries - now with pipes by Mark Seemann
Slightly improved syntax for defining ad-hoc, in-line Arbitraries for FsCheck.Xunit.
Last year, I described how to define and use ad-hoc, in-line Arbitraries with FsCheck.Xunit. The final example code looked like this:
[<Property(QuietOnSuccess = true)>] let ``Any live cell with > 3 live neighbors dies`` (cell : int * int) = let nc = Gen.elements [4..8] |> Arb.fromGen Prop.forAll nc (fun neighborCount -> let liveNeighbors = cell |> findNeighbors |> shuffle |> Seq.take neighborCount |> Seq.toList let actual : State = calculateNextState (cell :: liveNeighbors |> shuffle |> set) cell Dead =! actual)
There's one tiny problem with this way of expressing properties using Prop.forAll: the use of brackets to demarcate the anonymous multi-line function. Notice how the opening bracket appears to the left of the
fun keyword, while the closing bracket appears eleven lines down, after the end of the expression
Dead =! actual.
While it isn't pretty, I haven't found it that bad for readability, either. When you're writing the property, however, this syntax is cumbersome.
Issues writing the code #
After having written
Prop.forAll nc, you start writing
(fun neighborCount -> ). After you've typed the closing bracket, you have to move your cursor one place to the left. When entering new lines, you have to keep diligent, making sure that the closing bracket is always to the right of your cursor.
If you ever need to use a nested level of brackets within that anonymous function, your vigilance will be tested to its utmost. When I wrote the above property, for example, when I reached the point where I wanted to call the calculateNextState function, I wrote:
let actual : State = calculateNextState (
The editor detects that I'm writing an opening bracket, but since I have the closing bracket to the immediate right of the cursor, this is what happens:
let actual : State = calculateNextState ()
What normally happens when you type an opening bracket is that the editor automatically inserts a closing bracket to the right of your cursor, but in this case, it doesn't do that. There's already a closing bracket immediately to the right of the cursor, and the editor assumes that this bracket belongs to the opening bracket I just typed. What it really should have done was this:
let actual : State = calculateNextState ())
The editor doesn't have a chance, though, because at this point, I'm still typing, and the code doesn't compile. None of the alternatives compile at this point. You can't really blame the editor.
To make a long story short, enclosing a multi-line anonymous function in brackets is a source of errors. If only there was a better alternative.
Backward pipe #
The solution started to dawn on me because I've been learning Haskell for the last half year, and in Haskell, you often use the
$ operator to get rid of unwanted brackets. F# has an equivalent operator:
<|, the backward pipe operator.
I rarely use the
<| operator in F#, but in this case, it works really well:
[<Property(QuietOnSuccess = true)>] let ``Any live cell with > 3 live neighbors dies`` (cell : int * int) = let nc = Gen.elements [4..8] |> Arb.fromGen Prop.forAll nc <| fun neighborCount -> let liveNeighbors = cell |> findNeighbors |> shuffle |> Seq.take neighborCount |> Seq.toList let actual : State = calculateNextState (cell :: liveNeighbors |> shuffle |> set) cell Dead =! actual
Notice that there's no longer any need for a closing bracket after
Dead =! actual.
When the last argument passed to a function is another function, you can replace the brackets with a single application of the
<| operator. I only use this operator sparingly, but in the case of in-line ad-hoc FsCheck Arbitraries, I find it useful.
Addendum 2016-05-17: You can get rid of the
nc value with TIE fighter infix notation.