digitalmars.D - Function overloads/implicit conversions

John C (28/28) Jan 21 2006 Should implicit conversions be allowed to occur with function overloads?...

Unknown W. Brackets (3/51) Jan 21 2006 Cast the null to an Object. It has to match implicitly without other

John C (13/64) Jan 21 2006 Right. Here's another.

Unknown W. Brackets (8/85) Jan 21 2006 It's not simple in that it's easy to get around. It's simple in that it...

"John C" <johnch_atms hotmail.com> writes:

Should implicit conversions be allowed to occur with function overloads? I 
think not. At any rate, the behaviour seems inconsistent.

Case 1:

    void test(int a, Object b) {}
    void test(ulong a, Object b) {}

    test(100, null); // The compiler complains about mulitple matches.
    test(cast(int)100, null); // The compiler complains about mulitple 
matches.

Case 2:

    void test(int a, Object b) {}
    void test(ulong a, Object b) {}

    test(100, new Object); // The compiler picks the right overload (int).

Case 3:

    void test(int a, Object b = null) {}
    void test(ulong a, Object b = null) {}

    test(100, null); // The compiler complains about mulitple matches.
    test(cast(int)100, null); // The compiler complains about mulitple 
matches.

Case 4:

    void test(int a, Object b = null) {}
    void test(ulong a, Object b = null) {}

    test(100); // The compiler picks the right overload (int).

Case 5:

    void test(int a, Object b = null) {}
    void test(ulong a, Object b = null) {}

    test(100, new Object); // The compiler picks the right overload (int).


Can anyone explain why cases 1 & 3 fail to match?

Thanks.

Jan 21 2006

"Unknown W. Brackets" <unknown simplemachines.org> writes:

Cast the null to an Object.  It has to match implicitly without other 
possibles, or exactly... iirc.

-[Unknown]


 Should implicit conversions be allowed to occur with function overloads? I 
 think not. At any rate, the behaviour seems inconsistent.
 
 Case 1:
 
     void test(int a, Object b) {}
     void test(ulong a, Object b) {}
 
     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.
 
 Case 2:
 
     void test(int a, Object b) {}
     void test(ulong a, Object b) {}
 
     test(100, new Object); // The compiler picks the right overload (int).
 
 Case 3:
 
     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}
 
     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.
 
 Case 4:
 
     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}
 
     test(100); // The compiler picks the right overload (int).
 
 Case 5:
 
     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}
 
     test(100, new Object); // The compiler picks the right overload (int).
 
 
 Can anyone explain why cases 1 & 3 fail to match?
 
 Thanks.

Jan 21 2006

"John C" <johnch_atms hotmail.com> writes:

"Unknown W. Brackets" <unknown simplemachines.org> wrote in message 
news:dqu20f$1qno$1 digitaldaemon.com...
 Cast the null to an Object.  It has to match implicitly without other 
 possibles, or exactly... iirc.

Right. Here's another.

    interface Base {}
    class Derived : Base {}

    void test(int a, Base b) {}
    void test(ulong a, Base b) {}

With this code the compiler thinks there's multiple matches:

    test(100, new Derived);

But it accepts this:

    test(100, cast(Base)(new Derived));

In what way was there any ambiguity with the first, cast-less form? And D's 
overloading claims to be simple. How depressing.

 -[Unknown]


 Should implicit conversions be allowed to occur with function overloads? 
 I think not. At any rate, the behaviour seems inconsistent.

 Case 1:

     void test(int a, Object b) {}
     void test(ulong a, Object b) {}

     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.

 Case 2:

     void test(int a, Object b) {}
     void test(ulong a, Object b) {}

     test(100, new Object); // The compiler picks the right overload 
 (int).

 Case 3:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.

 Case 4:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100); // The compiler picks the right overload (int).

 Case 5:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100, new Object); // The compiler picks the right overload 
 (int).


 Can anyone explain why cases 1 & 3 fail to match?

 Thanks.

Jan 21 2006

"Unknown W. Brackets" <unknown simplemachines.org> writes:

It's not simple in that it's easy to get around.  It's simple in that it 
isn't complicated (the dictionary definition.)

It matches exactly, it matches only once ambiguously, or not at all.

It may be annoying, but I like it.  Why?  Because I will NEVER have to 
worry about the wrong thing happening.  If I ever add a new function or 
make a change that is ambiguous, I will know.  It won't silently cause 
problems.

-[Unknown]


 "Unknown W. Brackets" <unknown simplemachines.org> wrote in message 
 news:dqu20f$1qno$1 digitaldaemon.com...
 Cast the null to an Object.  It has to match implicitly without other 
 possibles, or exactly... iirc.

 
 Right. Here's another.
 
     interface Base {}
     class Derived : Base {}
 
     void test(int a, Base b) {}
     void test(ulong a, Base b) {}
 
 With this code the compiler thinks there's multiple matches:
 
     test(100, new Derived);
 
 But it accepts this:
 
     test(100, cast(Base)(new Derived));
 
 In what way was there any ambiguity with the first, cast-less form? And D's 
 overloading claims to be simple. How depressing.
 
 -[Unknown]


 Should implicit conversions be allowed to occur with function overloads? 
 I think not. At any rate, the behaviour seems inconsistent.

 Case 1:

     void test(int a, Object b) {}
     void test(ulong a, Object b) {}

     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.

 Case 2:

     void test(int a, Object b) {}
     void test(ulong a, Object b) {}

     test(100, new Object); // The compiler picks the right overload 
 (int).

 Case 3:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100, null); // The compiler complains about mulitple matches.
     test(cast(int)100, null); // The compiler complains about mulitple 
 matches.

 Case 4:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100); // The compiler picks the right overload (int).

 Case 5:

     void test(int a, Object b = null) {}
     void test(ulong a, Object b = null) {}

     test(100, new Object); // The compiler picks the right overload 
 (int).


 Can anyone explain why cases 1 & 3 fail to match?

 Thanks.

Jan 21 2006

D Programming

C/C++ Programming

Other

digitalmars.D - Function overloads/implicit conversions