Back to Questions
2.4k
views2
comments
Type inference seems to have trouble with trivial situation in .NET 4
f#compiler.net

Some trivial code:

1
2
3
4
5
6
7
8
9
10
11
12

let toQueryString nvpairs =

    String.Join("&",

        nvpairs

        |> Seq.map(fun (n,v) -> n + "=" + (urlEncodeUpper v))

        |> Seq.toArray

    )

This works just fine in a project that's configured to compile for .NET 3.5.

But in another almost identical project set to compile for .NET 4.0, the same code fails, telling me that it needs a type annotation to resolve the overload. When I run my mouse over the parameter nvpairs though, it does know that it's a (string*string) seq.

On the other hand, this works:

1
2
3
4
5
6
7
8
9
10
11
12

let toQueryString nvpairs =

    let formattedPairs:string array =

        nvpairs

        |> Seq.map(fun (n,v) -> n + "=" + (urlEncodeUpper v))

        |> Seq.toArray

    String.Join("&", formattedPairs)

If I remove the type annotation on formattedPairs, String.Join() confuses the compiler again -- even though I can still run my mouse over it and see that it's a string array.

I wonder what's going on?

.

Hi,

just a guess but I think the problem might be because the String.Join method got some more overloads in .net 4 - (it can now handle IEnumerable(of String) instead of only arrays and it can handle generic IEnumerable(of T) in conection with T.ToString() of course).

I guess the problem comes from this.

To test this I have written a simple testprogram:

open System

let encode (v) =

v.ToString()

let toQuery nvPairs =

let formattedPairs =

nvPairs

|> Seq.map( fun (n,v) -> n + "=" + encode(v) )

|> Seq.toArray

String.Join("&", formattedPairs)

and yes I get the red lines and the error.

But when I look into the Error List (as hinted by the GUI) I can see that yes there is a confusion by 5 possible overloads - so I don't think you can blame the F# compiler.

Greetings,

Carsten

PS: Hmm it's indeed starge: if I simply say (nvPairs : (string * _) seq) the confusion is gone.

So there seems to be a deeper hidden cause.

Maybe some internal can shed some light here.

By on 7/21/2010 4:40 AM ()

The issue actually has to do with how the + operator is applied to string arguments. Imagine that you created the following types:

1
2
3
4

type A() = 
  static member (+)(a:A,s:string) = B()
type B() =
  static member (+)(b:B,s:string) = obj()

Given this type, then you could give nvPairs the type (A * _) seq, which would result in formattedPairs having the type object[], which would result in calling a different String.Join overload in .NET 4. Thus, you really do need to add an annotation somewhere to help the compiler out.

By on 7/21/2010 2:23 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper