The compiler infers the wrong type.

[gusty]

In some situations the compiler tries to unify a type argument contained in a generic type with the generic type itself.

Repro steps

open System
open System.Collections.Generic

let pInt = Int32.TryParse >> function (true, x) -> Some x | _ -> None 

let pString (x:string) = 
    match x.Trim() with
    | x when x.[0..0] = "\"" && x.[x.Length-1..x.Length-1] = "\"" -> Some x.[1..x.Length-2]
    | _ -> None 

let pTuple2 p1 p2 (x:string) =
    match x.Trim() with
    | x when x.[0..0] = "(" && x.[x.Length-1..x.Length-1] = ")" -> 
        let x = x.[1..x.Length-2]
        match x.Split(',') with
        | [|a; b|] -> match (p1 a, p2 b) with (Some a, Some b) -> Some (a, b) | _ -> None
        | _ -> None
    | _ -> None 

let pList (p:string -> 'a option) (x:string) =
    match x.Trim() with
    | x when x.[0..0] = "[" && x.[x.Length-1..x.Length-1] = "]" -> 
        let x = x.[1..x.Length-2]
        let x = x.Split(';') |> Array.map p
        if x |> Array.forall (fun x -> x.IsSome) then
            Some (Array.choose id x |> Array.toList)
        else None
    | _ -> None

type TryParseCs = TryParseCs with        
    static member TryParse (_: int   ) = pInt    
    static member TryParse (_: string) = pString

let inline iTryParse (a: ^a, b: ^b) =  ((^a or ^b) : (static member TryParse: ^b -> (string -> ^b option)) b)
let inline tryParse (x: string) : 'a option = iTryParse (TryParseCs, Unchecked.defaultof<'a>) x

type TryParseCs with
    static member inline TryParse (_: IDictionary<string, 'a>) : string -> option<IDictionary<string, 'a>> =
        pList (pTuple2 pString tryParse) >> function
        | Some x -> Some (dict x )
        | _ -> None

    static member inline TryParse (_: 'a ResizeArray) : string -> option<'a ResizeArray> = pList tryParse >> function
        | Some x -> Some (ResizeArray<_>(x))
        | _ -> None

Expected behavior

val inline tryParse :
  x:string ->  ^a option
    when (TryParseCs or  ^a) : (static member TryParse :  ^a ->
                                                       string ->
                                                          ^a option)

Actual behavior

It doesn't compile

~vs4AFB.fsx(43,98): error FS0043: Type mismatch. Expecting a
    string -> 'a option    
but given a
    string -> ResizeArray<'a> option    
The resulting type would be infinite when unifying ''a' and 'ResizeArray<'a>'

Known workarounds

At the end of the code add this overload:

static member TryParse (_: 'a Tuple) : string -> option<Tuple<'a>> = fun _ -> Some (Tuple<'a>(Unchecked.defaultof<'a>))

Related information

This was reported as a bug in Fleece.

[dsyme]

I haven't taken a long look, but on a quick glance it's not clear to me from the repro that this is a bug.

Type annotations are commonly needed to help disambiguate method overloading, especially in the presence of statically resolved member constraints.

If a simpler repro could be provided that would be helpful. Until then I think this would be considered by design

[gusty]

@dsyme This is a small repro. If you have a look at the actual code in Fleece it's thousand of lines.
I can certainly make it smaller by faking all the parsing functions but the idea was to show a minimal functionality, in fact the interesting stuff begins at the end of the script, with the type declaration: type TryParseCs = TryParseCs with and so on.

I don't think this is by design and here the problem is not to disambiguate, on the contrary is to "ambiguate", because that's what type inference is doing here, it's trying to disambiguate when in fact the code is generic and should not continue trying to resolve to a specific method. The workaround makes type inference "ambiguate" and then it works, but that shouldn't be necessary.

[dsyme]

@gmpl If you could change the title to clarify what you believe the error in the compiler is that would be helpful.

The current title, "The compiler tries to unify a type argument contained in a generic type with the generic type", doesn't describe a bug - it describes correct behavior - i.e. the spec of the compiler today is that unifying "T" and "List" will give an error. So please at least adjust the title of the issue to indicate what you think the bug is, thanks.

Stubbing all the parser functions would also be good. In general 99% of F# type checking problems repro in under 10 lines, often in 2 :)

[gusty]

@dsyme Here's a stubbed version:

open System
open System.Collections.Generic

let pString (x:string) = Some ""
let pTuple2 (p1: _ -> _ option) (p2: _ -> _ option) (x:string) = Some ((p1 "").Value , (p2 "").Value)
let pList (p:string -> 'a option) (x:string) = Some ([] : 'a list)

type TryParse = TryParse with
    static member        ($) (TryParse, _: int                    ) = fun (_:string) -> Some 0    
    static member        ($) (TryParse, _: string                 ) = pString
    static member inline ($) (TryParse, _: IDictionary<string, 'a>) : string -> option<IDictionary<string, 'a>> = pList (pTuple2 pString (TryParse $ Unchecked.defaultof<'a>)) >> fun x -> Some (dict x.Value)
    static member inline ($) (TryParse, _: 'a ResizeArray) : string -> option<'a ResizeArray> = pList (TryParse $ Unchecked.defaultof<'a>) >> fun x -> Some (ResizeArray<_> x.Value)
    // workaround -> static member ($) (TryParse, _: 'a Tuple) : string -> option<Tuple<'a>> = fun _ -> Some (Tuple<'a> Unchecked.defaultof<'a>)

~vsE8D9.fsx(12,162): error FS0001: Type mismatch. Expecting a
    ResizeArray<'a>    
but given a
    List<ResizeArray<'a>>    
The resulting type would be infinite when unifying ''a' and 'ResizeArray<'a>'
> 

If you prefer it I can update the original repro. I can also keep the original "full code" in a gist.
Note that the code now it's 12 lines, 9 without counting the opens ;)

[dsyme]

Thanks for minimizing the repro.

[forki]

I think we should remove the "resolution by design" label