www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.bugs - [Issue 6714] New: Function literal does not convert to "function" and "delegate" types

reply d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714

           Summary: Function literal does not convert to "function" and
                    "delegate" types
           Product: D
           Version: unspecified
          Platform: Other
        OS/Version: Mac OS X
            Status: NEW
          Severity: normal
          Priority: P2
         Component: DMD
        AssignedTo: nobody puremagic.com
        ReportedBy: andrei metalanguage.com


--- Comment #0 from Andrei Alexandrescu <andrei metalanguage.com> 2011-09-22
07:31:43 PDT ---
Consider:


void foo (int function (int, int) a){}
void bar (int delegate (int, int) a){}

void main ()
{
    foo((a, b) { return a +b;});
    bar((a, b) { return a +b;});
}

Neither call works. The literal does not convert to the function or the
delegate type.

Additionally (this might have been reported), a function type should convert
automatically to a delegate type with the same arguments and return type.
Walter has expressed doubts about that. The doubts are unfounded.

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Sep 22 2011
next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714


Andrei Alexandrescu <andrei metalanguage.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|Function literal does not   |[tdpl] Function literal
                   |convert to "function" and   |does not convert to
                   |"delegate" types            |"function" and "delegate"
                   |                            |types


--- Comment #1 from Andrei Alexandrescu <andrei metalanguage.com> 2011-12-18
20:06:05 PST ---
Related to http://d.puremagic.com/issues/show_bug.cgi?id=3235

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 18 2011
prev sibling next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714


Don <clugdbug yahoo.com.au> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |clugdbug yahoo.com.au


--- Comment #2 from Don <clugdbug yahoo.com.au> 2011-12-24 04:23:32 PST ---
(In reply to comment #0)

 Consider:
 
 
 void foo (int function (int, int) a){}
 void bar (int delegate (int, int) a){}
 
 void main ()
 {
     foo((a, b) { return a +b;});
     bar((a, b) { return a +b;});
 }
 
 Neither call works. The literal does not convert to the function or the
 delegate type.


This works though:
     bar((int a, int b) { return a + b;});
Is that what you meant? If it is, then this is a duplicate of 3235.

Or are argument types supposed to be deduced? If so, that's a major,
complicated feature and difficult to implement, I think it requires an extra
level of argument matching. It would need to be considered very carefully.
Eg, which of these calls are ambiguous?

void bar ( double delegate(int, int) a ) {}
void bar ( int delegate (int, int) a ){}

bar( (a, b) { return 1.0; } );
bar( (a, b) { return 1.0f; } );
bar( (a, b) { return a; } );

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 24 2011
prev sibling next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714



--- Comment #3 from Andrei Alexandrescu <andrei metalanguage.com> 2011-12-24
09:32:58 PST ---
(In reply to comment #2)

 (In reply to comment #0)

 Consider:
 
 
 void foo (int function (int, int) a){}
 void bar (int delegate (int, int) a){}
 
 void main ()
 {
     foo((a, b) { return a +b;});
     bar((a, b) { return a +b;});
 }
 
 Neither call works. The literal does not convert to the function or the
 delegate type.


 
 This works though:
      bar((int a, int b) { return a + b;});
 Is that what you meant? If it is, then this is a duplicate of 3235.
 
 Or are argument types supposed to be deduced? If so, that's a major,
 complicated feature and difficult to implement, I think it requires an extra
 level of argument matching.


When I discussed with Walter the matter a while ago, a possible approach was
that the literal relying on deduction defines a local template function. For
example, the code:

    foo((a, b) { return a +b;});

would be lowered into:

    static auto __lambda(T1, T2)(T1 a, T2 b) { return a + b; }
    foo(__lambda);

The "static" is present because the compiler figured the lambda uses no state
from the enclosing context. Built-in conversion mechanisms should take over
from here on.

This also brings the issue of automatically converting a function to a
delegate. Walter disagrees with that, but I disagree with the basis of his
disagreement.


 It would need to be considered very carefully.
 Eg, which of these calls are ambiguous?
 
 void bar ( double delegate(int, int) a ) {}
 void bar ( int delegate (int, int) a ){}
 
 bar( (a, b) { return 1.0; } );


Works, goes to first overload.


 bar( (a, b) { return 1.0f; } );


Doesn't work, no conversion possible for either overload.


 bar( (a, b) { return a; } );


Depends on a's type.

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 24 2011
prev sibling next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714


Don <clugdbug yahoo.com.au> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |rejects-valid, spec
            Version|unspecified                 |D2
            Summary|[tdpl] Function literal     |[tdpl] Type inference for
                   |does not convert to         |parameters of function and
                   |"function" and "delegate"   |delegate literals
                   |types                       |
         OS/Version|Mac OS X                    |All
           Severity|normal                      |enhancement


--- Comment #4 from Don <clugdbug yahoo.com.au> 2011-12-26 17:10:36 PST ---
(In reply to comment #3)

 (In reply to comment #2)

 (In reply to comment #0)

 Consider:
 
 
 void foo (int function (int, int) a){}
 void bar (int delegate (int, int) a){}
 
 void main ()
 {
     foo((a, b) { return a +b;});
     bar((a, b) { return a +b;});
 }


 Are argument types supposed to be deduced? If so, that's a major,
 complicated feature and difficult to implement, I think it requires an extra
 level of argument matching.


 
 When I discussed with Walter the matter a while ago, a possible approach was
 that the literal relying on deduction defines a local template function. 


Changing bug title from the original ´Function literal does not convert to
"function" and "delegate" types´, since this seems to be type inference
enhancement, which requires a spec change.


 For example, the code:
 
     foo((a, b) { return a +b;});
 
 would be lowered into:
 
     static auto __lambda(T1, T2)(T1 a, T2 b) { return a + b; }
     foo(__lambda);
 
 The "static" is present because the compiler figured the lambda uses no state
 from the enclosing context. Built-in conversion mechanisms should take over
 from here on.


I don't understand how this works. Where does the template get instantiated?

In the examples at the end of comment 3, it seems to be deducing the parameters
of __lambda from parameters of foo. This seems very complicated. 
If foo is a template function, in every existing situation, all the types of
the arguments are known. Here, they aren't. For example if foo is:

void foo(T = int, R)( R function(T, T) f)

then we'd expect T1, T2 to be deduced as int (because of the default value of
T). We now have enough information to instantiate __lambda, which then allows
us to determine R. We can then finally instantiate foo. We're instantiating two
templates at once, and they're kind of interlocked. The interlocking continues
further: if the parameter deduction or template constraint of foo fails, then
the instantiation of __lambda must also be discarded.
The 4-step template argument deduction process described in template.html is
gone.


 This also brings the issue of automatically converting a function to a
 delegate. Walter disagrees with that, but I disagree with the basis of his
 disagreement.


Obviously this needs to be resolved.

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 26 2011
prev sibling next sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714


Kenji Hara <k.hara.pg gmail.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |patch


--- Comment #5 from Kenji Hara <k.hara.pg gmail.com> 2011-12-30 21:23:58 PST ---
https://github.com/D-Programming-Language/dmd/pull/588

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 30 2011
prev sibling parent d-bugmail puremagic.com writes:
http://d.puremagic.com/issues/show_bug.cgi?id=6714


Walter Bright <bugzilla digitalmars.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
                 CC|                            |bugzilla digitalmars.com
         Resolution|                            |FIXED


--- Comment #6 from Walter Bright <bugzilla digitalmars.com> 2011-12-31
12:24:37 PST ---
https://github.com/D-Programming-Language/dmd/commit/c50eb5f5726a65efa1224ff0f0fd60acbb6e3027

-- 
Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
Dec 31 2011