Compilation error when implementing interface using object expressions and tuple argument

[JanWosnitza]

Surprising compilation error when trying to implement an interface using object expressions.

Repro Steps

type IInterface =
    abstract Function : (int32 * int32) -> unit

{ new IInterface with
    member this.Function (i, j) = ()
}

Expected

Compilation without errors like this:

type IInterface =
    abstract Function : int32 -> unit

{ new IInterface'with
    member this.Function (i) = ()
}

Actual

The compilation error is:

FS0768: The member 'Function' does not accept the correct number of arguments, 1 arguments are expected

Severity

• Confusing for newcomers.
• Cumbersome to remember.
• But easy workaround.

Version

• F# 4.0 (FSharp.Core, 4.4.0.0)
• F# Compiler version 14.0.23413.0
• .NET Runtime, Framwork 4.6
• Windows 10
• Visual Studio Community 2015 version 14.0.2513.00 Update 2

Workaround

Surround the error producing parameter with additional brackets:

type IInterface =
    abstract Function : (int32 * int32) -> unit

{ new IInterface with
    member this.Function ((i, j)) = ()
}

[forki]

I reproduced this with the current master.

I think what you want to do is:

type IInterface =
    abstract Function : int32 * int32 -> unit

{ new IInterface with
    member this.Function (i, j) = ()
}

Apaprently there is a difference between

    abstract Function : int32 * int32 -> unit

and

    abstract Function : (int32 * int32) -> unit

The latter one is making it a tuple.

[forki]

@dsyme Am I right that this is actually by design?

If so then let's discuss if we could improve the error message instead.

• it should be singular
• it could hint the signature of Function
• it could tell something about tuples vs. "C# style parameters"

[isaacabraham]

@forki My thoughts exactly. If this becomes a fully fledged "improve error message" I'll add it to the (growing!) list.

[JanWosnitza]

Apaprently there is a difference between

abstract Function : int32 * int32 -> unit

and

abstract Function : (int32 * int32) -> unit

The latter one is making it a tuple.

Ah ok, I wasn't aware of that particular behavior. I added the brackets only in an attempt to increase readability. But still, I would expect the pattern matching of tuples to handle the situation without the additional brackets (@forki: maybe that's the design you mentioned?).

Of course, an improved error message would have helped. I think the error-message should also mention the reason why the additional brackets are necessary in the first place. So one might deduce the possibility to remove the brackets in the definition instead.

Nevertheless, personally I would appreciate if I had to make double brackets in the definition when it should become a tuple. This would also lead to a "symmetric" syntax at the declaration and at the implementation side, and would feel more explicit (at least for me).

type IInterface =
    abstract Function : ((int32 * int32)) -> unit

{ new IInterface with
    member this.Function ((i, j)) = ()
}

let f   (a, b)  = () // val f  : a:'a * b:'b -> unit
let f' ((a, b)) = () // val f' :   'a *   'b -> unit

let g   (a, b)  x = () // val g  : a:'a * b:'b -> x:'c -> unit
let g' ((a, b)) x = () // val g' :   'a *   'b -> x:'c -> unit

[isaacabraham]

The latter part should be a UV request as a language change. Could you create a new issue though for the error message one as per the other ones that have recently been created with same format (what / why / how)?

[dsyme]

Closing as this is by design (and error message improvement is tracked by a separate bug)