Statically typed equality test

[tpetricek]

In an earlier version, there used to be shouldEqual primitive that beahaved like y |> should equal x but statically required x and y to have the same type.

I find that extremely useful - I was using some untyped equal constraints and it quite regularly caused trouble where test would compile, but fail - when I changed some API.

Can we have this function (or some alternative) back?

[fsoikin]

+1 on this.

Here is a simple repro:

let someFn x = 
   match x with 
      | 42 -> []
      | _ -> [1;x]

[<Test>]
let ``someFn should return empty list when given 42``() =
   someFn 42
   |> should equal []

The test fails and error message cryptically states that Expected: [], was: []

[dtchepak]

+1. It would be useful to support statically typed matchers in other cases too. I am currently trying the following (not tested yet, please point out errors):

let inline equalWithin t x =
    let isInRange y = y <= x+t && y>= x-t
    NHamcrest.CustomMatcher<_>(sprintf "%s with a tolerance of %s" (string x) (string t), fun v -> isInRange v)

let inline should' m expected actual = Xunit.Assert.That(actual, m expected)

This has the advantage of equalWithin working on any comparable type that supports -, + (including DateTime with TimeSpan tolerance). The current equalWithin only works with objects whose string representations parse as doubles.

[sergey-tihon]

Released in v2.2.0-beta1