On 09/03/2011 11:34 AM, Jacob Carlborg wrote:
On 2011-09-02 21:11, Andrej Mitrovic wrote:
Code:
void main()
{
auto foo = (int x = 10){ /* */ };
void delegate() bar = foo;
}
Since foo takes an argument that already has a default it can be used
as a simple `void delegate()`, so maybe it makes sense for `foo` to be
able to implicitly convert to such a type.
Unfortunately doing a cast doesn't work properly:
import std.stdio;
void main()
{
auto foo = (int x = 10){ writeln(x); };
void delegate() bar;
bar = cast(typeof(bar))foo;
bar(); // prints garbage
}
So maybe this type of conversion is impossible in the first place due
to how arguments are passed? I don't know all the technical tidbits,
but from a user's point of view an implicit conversion kind of makes
sense (if it's possible).
I think it would be usable. I also think that a delegate/function that
returns a value could be implicitly converted to a delegate/function of
the same signature but returns void instead. I would be the same as
calling the delegate that returns a value and not assign the returned
value to a variable.
Note that this would also require a thunk that explicitly discards the
result value in non-trivial cases.
