`should equal` fails when `Assert.Equal` doesn't

Description

should equal fails when Assert.Equal doesn’t

Repro steps

module SomethingIsWrong

open System.Threading.Tasks
open FSharp.Control.Tasks.V2.ContextInsensitive
open FsUnit.Xunit
open FsUnit.CustomMatchers
open Xunit

[<Fact>]
let test () = task{
    let! result = task{
        match! Task.FromResult(Error "error") with
        | Error error -> return Error error 
        | Ok _ -> return Ok()
    }
    
    // works 
    result = Error "error" |> should equal true
    
    // works
    Assert.Equal(result, Error "error")
    
    // fails
    result |> should equal (Error "error")
}

Expected behavior

The test passes

Actual behavior

should equal fails with “FsUnit.Xunit+MatchException : Exception of type ‘FsUnit.Xunit+MatchException’ was thrown. Expected: Equals Error “error” Actual: was Microsoft.FSharp.Core.FSharpResult`2[Microsoft.FSharp.Core.Unit,System.String]”

Related information

• Linux 5.4.2-1-MANJARO
• dotnet sdk 3.1.100
• FsUnit.xUnit 3.8.0

[CaptnCodr]

I figured it out and have a solution for you.

In your last assertion you may have to add the explicit type to your Error, e.g.: result |> should equal (Result<unit, string>.Error "error")

I’m very surprised that the compiler can’t infer the type for this assertion.

[CaptnCodr]

I tested it with a simpler example which results in a same way:

let result = 
   match Error "error" with
        | Error error -> Error error 
        | Ok _ -> Ok ()

result |> should equal (Error "error")

The match expression is the tie breaker here.

I think the Assert.Equal(result, Result.Error "error") has an internal bind to infer the correct type.

Edit: Same thing with the equality operator: (result = Error "error") |> should equal true // works result.Equals(Error "error") |> should equal true // fails result.Equals(Result<unit, string>.Error "error") |> should equal true // works

Edit 2: Problem is: result from above is Result<unit, string> and the Result.Error "error" has only the type of Result<'a, string> where 'a is unknown.

You may also use the Result.map function like this: result |> should equal (Result.Error "error" |> Result.map (fun _ -> ())) to enforce the unit type on the left side (Result.Ok ()).

Is it worth it to place this topic into the F# repo as a bug? I think this is a little difficult to decide the compiler does all the work it has no chance to infer the left type.

This is not in FsUnit because you can reproduce this without the FsUnit operators, too.