I have some code like this:

struct Foo
{
	this(int i)
	{
		//do something useful
	}
}

void bar(Foo f)
{
	//do something else
}

void main()
{
	Foo f = 5;//works
	
	bar(f);//works
	
	bar(Foo(5));//works
	
	bar(5);//Error: function app.bar (Foo f) is not callable using argument types (int)
}


D can't implicitly convert type "int" to type "Foo", but constructor "Foo(int)" exists. Explicit conversion works fine.
What should I do to support this convertion implicitly?

On Wednesday, 4 September 2013 at 19:36:08 UTC, ilya-stromberg wrote:
> I have some code like this:
>
> struct Foo
> {
> 	this(int i)
> 	{
> 		//do something useful
> 	}
> }
>
> void bar(Foo f)
> {
> 	//do something else
> }
>
> void main()
> {
> 	Foo f = 5;//works
> 	
> 	bar(f);//works
> 	
> 	bar(Foo(5));//works
> 	
> 	bar(5);//Error: function app.bar (Foo f) is not callable using argument types (int)
> }
>
>
> D can't implicitly convert type "int" to type "Foo", but constructor "Foo(int)" exists. Explicit conversion works fine.
> What should I do to support this convertion implicitly?

What's about:

void bar(int i) {
    bar(Foo(i));
}

?

On Wednesday, 4 September 2013 at 19:44:17 UTC, Namespace wrote:
>
> What's about:
>
> void bar(int i) {
>     bar(Foo(i));
> }
>
> ?

No, I wrote very simple example. I have 10 "from" types and a lot of different "bar" functions. Your way will be more painful then explicit conversion.

So you can use templates, something like this:


bool isConvertableToFoo(T)
{
    T i = void;
    return is(typeof(Foo(i)) == Foo);
}

void bar(T)(T i) if (is(T : Foo))
{
    //some code
}

void bar(T)(T i) if (!is(T : Foo) && isConvertableToFoo!T)
{
    bar(Foo(i));
}


I do not test it so it is maybe not completly correct :).
On Wednesday, 4 September 2013 at 19:54:44 UTC, ilya-stromberg wrote:
> On Wednesday, 4 September 2013 at 19:44:17 UTC, Namespace wrote:
>>
>> What's about:
>>
>> void bar(int i) {
>>    bar(Foo(i));
>> }
>>
>> ?
>
> No, I wrote very simple example. I have 10 "from" types and a lot of different "bar" functions. Your way will be more painful then explicit conversion.

On Wednesday, 4 September 2013 at 20:14:06 UTC, Kozzi wrote:
> So you can use templates, something like this:

I know, it will work. But I really have **a lot of** different "bar" functions, so that way will be painful.

So, the question is: what should I add to "Foo" struct to allow implicit conversions from "int" to "Foo"?

On Wednesday, 4 September 2013 at 20:25:28 UTC, ilya-stromberg wrote:
> So, the question is: what should I add to "Foo" struct to allow implicit conversions from "int" to "Foo"?

D does not support implicit struct construction.

Interestingly though, it *does* support it for functions taking classes:

class Foo {
        this(int i) {}
}

void foo(Foo f...) {}

void main() {
        foo(10);
}


But there's nothing like it for structs.

On 09/04/2013 01:46 PM, Adam D. Ruppe wrote:

> D does not support implicit struct construction.

That's what I knew.

> Interestingly though, it *does* support it for functions taking classes:
>
> class Foo {
>          this(int i) {}
> }
>
> void foo(Foo f...) {}
>
> void main() {
>          foo(10);
> }

WHAT? :) It even new's one?

But it works only for the ellipsis.

I wonder why the discrepancy...

Ali

On Wednesday, 4 September 2013 at 21:14:26 UTC, Ali Çehreli wrote:
> On 09/04/2013 01:46 PM, Adam D. Ruppe wrote:
>
> > D does not support implicit struct construction.
>
> That's what I knew.
>
> > Interestingly though, it *does* support it for functions
> taking classes:
> >
> > class Foo {
> >          this(int i) {}
> > }
> >
> > void foo(Foo f...) {}
> >
> > void main() {
> >          foo(10);
> > }
>
> WHAT? :) It even new's one?
>
> But it works only for the ellipsis.
>
> I wonder why the discrepancy...
>
> Ali

http://dlang.org/function.html Under Typesafe Variadic Functions -> For class objects.

On Wed, Sep 04, 2013 at 02:14:26PM -0700, Ali Çehreli wrote:
> On 09/04/2013 01:46 PM, Adam D. Ruppe wrote:
> 
> > D does not support implicit struct construction.
> 
> That's what I knew.
> 
> > Interestingly though, it *does* support it for functions taking classes:
> >
> > class Foo {
> >          this(int i) {}
> > }
> >
> > void foo(Foo f...) {}
> >
> > void main() {
> >          foo(10);
> > }
> 
> WHAT? :) It even new's one?
> 
> But it works only for the ellipsis.
> 
> I wonder why the discrepancy...
[...]

Whoa. I never knew about this! It's ... I don't know what to say. It seems to be a cool feature, but it's also ... so scary. Implicit new's just leaves a lump in my throat. Is this an actual, intentional feature??!


T

-- 
If you want to solve a problem, you need to address its root cause, not just its symptoms. Otherwise it's like treating cancer with Tylenol...

On Wednesday, 4 September 2013 at 23:00:07 UTC, H. S. Teoh wrote:
> On Wed, Sep 04, 2013 at 02:14:26PM -0700, Ali Çehreli wrote:
>> On 09/04/2013 01:46 PM, Adam D. Ruppe wrote:
>> 
>> > D does not support implicit struct construction.
>> 
>> That's what I knew.
>> 
>> > Interestingly though, it *does* support it for functions taking
>> > classes:
>> >
>> > class Foo {
>> >          this(int i) {}
>> > }
>> >
>> > void foo(Foo f...) {}
>> >
>> > void main() {
>> >          foo(10);
>> > }
>> 
>> WHAT? :) It even new's one?
>> 
>> But it works only for the ellipsis.
>> 
>> I wonder why the discrepancy...
> [...]
>
> Whoa. I never knew about this! It's ... I don't know what to say. It
> seems to be a cool feature, but it's also ... so scary. Implicit new's
> just leaves a lump in my throat. Is this an actual, intentional
> feature??!
>
>
> T

It, in theory, doesn't allocate memory:
"An implementation may construct the object or array instance on the stack. Therefore, it is an error to refer to that instance after the variadic function has returned"