Improve error reporting: Function accidentally partially applied

[isaacabraham]

What

Oftentimes, you may add a curried argument to a function after the fact, or called a curried function and simply forgot the last argument. All callsites will break (correct) but the error is generally not what you would expect. Look at the following example: -

let foo a b = a + b
let c = foo 10
let d = c + 10

The error returned is error FS0001: The type 'int' does not match the type 'int -> int'

Why

New developers to F# may be unfamiliar with the concept of pervasive type inference and / or of passing functions as values and / or of partially applied functions. The error message does not make entirely clear why this error is occurring.

How

This makes sense, but again, to a new developer, it's completely confusing. A preferred error may be something like: -

The value 'c' is a partially applied function with signature 'int -> int' and is not compatible with 10. Did you forget to provide all the partial arguments when creating 'c'?

If it is not easily possible from the AST to understand that this is a partially applied function (entirely possible), it should still be possible to make a clearer message saying you are trying to do something across a function and a simple value.

[smoothdeveloper]

The value 'c' is a partially applied function with signature 'int -> int' and is not compatible with 'operator (+) int -> int -> int'. Did you forget to provide missing arguments to call 'c'?

[isaacabraham]

@smoothdeveloper what would that look like if you were passing in to another function e.g. bar c

where bar has signature int -> unit

Another example related to this is: -

let foo a b = a + b
let c = foo 10

which gives the following error message (!)
error FS0001: This expression was expected to have type int but here has type 'a -> 'c

[smoothdeveloper]

@isaacabraham, I think the message could say something like:

The value 'bar' expects a value of type 'int' but was given 'c' which has a value of type 'int -> int'

[isaacabraham]

I think something it's important to add something about the "did you forget to provide all arguments to the partial function" though - explaining that the types don't match is good, but we want to go further than that and show them where the underlying issue was most likely caused - in other words, to avoid them having to follow the breadcrumbs themselves.

[dsyme]

@isaacabraham I suspect partial application is a red-herring here - you would want to improve the error message whenever doing something like f + 1 where f is not given enough arguments.

I'm also saying that because tracking whether a function type arises from partial application is not something done in the compiler today. Adding that tracking would be a bit invasive on the compiler codebase. Sometimes you have to do it to get better error messages, but at first it is better to try to work using the information we have (a function type, and perhaps an expression f).

[isaacabraham]

@dsyme Yep. I'm not suggesting massive changes to the compiler (maybe when I get it building locally I'll be able to say more...) - I think all of these error message changes should be fairly low hanging fruits in terms of effort to implement and benefit to end users.