F# Computation Expression Method Overload Resolution Ordering

FooCe.fs

open System.Threading.Tasks

type FooBuilder() =

    member _.Return(x) = Task.FromResult(Ok x)

    member _.Bind(x, f) : Task<Result<'TResult, 'Error list>> =
        task {
            let! x = x

            match x with
            | Ok x -> return! f x
            | Error e -> return Error e
        }

    member _.Source(s: Task<Result<'TResult, 'Error list>>) = s

    member _.Source(s: Result<_, _ list>) = Task.FromResult s

[<AutoOpen>]
module LowerPriority =

    type FooBuilder with

        member _.Source(s: Task<'TResult>) =
            task {
                let! x = s
                return Ok x
            }

        member _.Source(s: Result<_, _>) =
            Task.FromResult(Result.mapError List.singleton s)


[<AutoOpen>]
module HigherPriority =
    
    type FooBuilder with
        member _.Source(s: Result<_, _ seq>) = Task.FromResult (Result.mapError List.ofSeq s)

let foo = FooBuilder()

let doit () =
    foo {
        let! x = Task.FromResult(Ok 1)

        let! y = Task.FromResult(2)

        let! z = Ok 3

        let! a = Error [ "a" ]
        let! b = Error "a"
        let! b = Error (Seq.singleton "a")

        return x + y + z + a + b
    }