Conditional parameter uncurrying

[ncave]

@alfonsogarciacaro I know by now you probably don't want to touch the uncurrying with a ten foot pole, so this is just asking for an opinion, it's not an issue or a feature request.

Since the uncurrying in parameters has been removed, do you think there may be some other way to bring it back conditionally, perhaps with a parameter-level attribute?

This is mostly for performance reasons, to avoid the unnecessary currying if a local lambda is already uncurried. This example shows the unnecessary currying, and the current work-around using Func<_> to remove it (which ideally that conditional feature would make happen automatically somehow).

module TestApp

open System
open type System.Console

let add3 x y z =
    let adder2 x y = x + y + z     // adder2 is auto-uncurried
    let add2 adder x y = adder x y // uses curried adder
    // let add2 (adder: Func<_,_,_>) x y = adder.Invoke(x, y) // uncurried `adder`, ideally that's what we want
    add2 adder2 x y                // adder2 will be curried here

[<EntryPoint>]
let main _args =
    let sum = add3 1 2 3
    WriteLine("sum: {0}", sum)
    0

[alfonsogarciacaro]

TBH, I don't have hard feelings towards the uncurrying mechanism. It's the way it is after a lot of trial and error, but I'm ok with improving/extending it if possible. From time to time I realize that some of my previous assumptions were wrong so it's very likely the algorithm still contains flaws. I think we are well covered by tests, so you can try to make a change and see if all the tests pass (particularly those in Applicative).

Although maybe I'm not understanding your request correctly. Currently the uncurrying does happen when passing parameters, but it's disabled when returning a function from another function (this is because there were many corner cases I couldn't fix). If I remember correctly these are the rules more or less:

• Functions are uncurried when passed as parameters (I don't remember exactly if there's a different rule for local functions).
• Functions returned are kept in curried form. If a function received as parameter is returned it will be curried again (because that's what the caller expects). I think that's what happening in your sample.

There's the special case of parameters of functions passed as parameters, which I would have to check to remember what happens with them

[ncave]

I guess what I meant is, funcs that are uncurried are then re-curried when passed in as parameters, as below.
But I see your point, the parameter type is curried so the argument passed in has to conform.
I'm not sure there is a good way around that.

    let adder2 x y = x + y + z      // here adder2 is uncurried
    let add2 adder x y = adder x y  // here adder type is curried
    add2 adder2 x y                 // so here adder2 has to be re-curried

Perhaps a transformation to uncurry parameter types and parameter usage in the body can work.
Not sure how brittle can that be.