Improve error reporting: Partially applied generic value vs function

[isaacabraham]

What

The following code snippet returns an error message which could be improved upon:

let foo2 = Seq.map((*) 2) >> Seq.filter(fun x -> x < 10) // not ok

error FS0030: Value restriction. The value 'foo2' has been inferred to have generic type
    val foo2 : ('_a -> seq<int>) when '_a :> seq<int>    
Either make the arguments to 'foo2' explicit or, if you do not intend for it to be generic, add a type annotation.

Why

This error is confusing in several ways: -

1. Explicitly providing the argument and moving from >> to |> removes the error e.g.

let foo a = a |> Seq.map((*) 2) |> Seq.filter(fun x -> x < 10) // ok

1. It is unfortunate that the compiler has correctly determined that seq<int> would be acceptable yet cannot use it.
2. Whilst the error message gives a couple of solutions, an example would help for both, or a URL to read up more on it. Also, the error message doesn't include a "why" this occurs. Granted, this may be too complex to do in this error message in this case, but I think that we should explore it nonetheless.

How

Open to suggestions here! Based on discussions with @swlaschin, @colinbull and @mavnn there are a few options. Let's start with this text: -

A let binding without a parameter creates a simple value and not a function. As this code is generic it has caused a value restriction. Consider adding a type annotation (or explicitly adding a parameter) to make this a function.

[dsyme]

Also, the error message doesn't include a "why" ....

With regard to the text: I do feel we should try to stick to the current format for errors, which is essentially "Error. Explanation. Suggestion". It's a good pattern and consistency is valuable. (We may decide to change the pattern, but we should only do that if we're really sure it's right and is setting a new precedent).

Here are some notes on the sections for this particular error:

Error section:

• For the "Error" text, i remember we did decide to use just "Value restriction". Saying more may be technically accurate but will almost certainly be confusing, e.g. saying Generic value restriction or Ungeneralizable code don't feel helpful. Perhaps Code can't be made generic automatically due to value restriction.

Explanation section:

• I think the main thing being proposed here is to add explanation (more "why")
• I would be loathe to drop the the inferred, non-generalizable type. The user will normally need to see this, e.g. to know where to add a constraint. If you can't see the type, then you can't spot why the thing you're defining is even generic.
• I do believe a full "why" explanation is going to be too hard (3 pages are devoted to this error in Expert F# alone, and it took a long time to write those pages :) ).
• The fragment you've given A let binding without a parameter creates a simple value and not a function feels helpful. However I don't like the use of "function" because of the subtle distinction between "function value" and "function".

Suggestions section:

• I quite like the two suggestions in the current error. Adding explicit parameters is the right solution in this case.

In short I recommend:

1. Please keep the "Error. Explanation. Suggestion" format unless you're sure we should change it.
2. Please keep the display of the ungeneralizable type.
3. Please be careful about the use of the word "function".

:) Thanks!

[isaacabraham]

Great points. I had the same concern regarding function on Twitter with Scott. I don't know what the word is though to distinguish between the two types of functions! To be honest I'm not the best person to comment on this one because I didn't even know why it happened in the first place - I just knew that to fix it 99% of the time I needed to manually supply the arguments into the function.

[smoothdeveloper]

I'm not following why this code is ok:

let foo1 () =
  let foo a = a |> Seq.map((*) 2) |> Seq.filter(fun x -> x < 10) // ok
  let foo2 = Seq.map((*) 2) >> Seq.filter(fun x -> x < 10) // ok too
  foo2 [1]

what makes that a top level foo2 in @isaacabraham sample is different than a local one? Is it because the local one can't be a generic function?

Is there any plan to support generic local function? (which would be a breaking change in light of this issue)

[dsyme]

@smoothdeveloper It's because you only apply foo2 to one type of thing (on the last line). If you try to apply it to multiple different types of things you'll have problems.

[smoothdeveloper]

@dsyme got it, fails if using it with both array and list. Thanks!

[isaacabraham]

Does that fail if it's declared at the module level rather than as a local function?

[dsyme]

@isaacabraham Yes (the value restriction means that the code has not been generalized, hence can't been used at multiple different types)

[smoothdeveloper]

module Foo =
  let foo2 = Seq.map((*) 2) >> Seq.filter(fun x -> x < 10)
  let foo1 () = 
    foo2 [|1|] |> ignore
    foo2 [1] |> ignore
    ()

gives

Error FS0001: This expression was expected to have type
    int []    
but here has type
    'a list