Implicit type conversion of an argument when a function is called

[John Colvin]

On Tuesday, 11 February 2014 at 03:45:30 UTC, Carl Sturtivant 
wrote:
>
> If I define a struct, and I want to pass a string to a function 
> with a parameter of type that very struct, is there any way to 
> arrange that an implicit conversion occurs, assuming a function 
> that maps a string to that struct type exists?
>
> struct data { ........ }
>
> void f( data x) { .... }
>
> void main() {
>     data( "hello"); //convert argument implicitly to type 
> `data`.
> }
>
> It's possible to arrange for such an implicit conversion from 
> an existing type to a newly defined type during assignment, but 
> what about when passing an argument to a function?

With a class you can do this:
class Data
{
	string s;
	this(string s)
	{
		this.s = s;
	}
}

void f(Data x ...)
{
	import std.stdio;
	writeln(x.s);
}

void main()
{
     f("hello"); //convert argument implicitly to type `data`.
}

See Typesafe Variadic Functions at http://dlang.org/function.html

I don't know why you can't do it with a struct.

As a workaround, you can do this:

class Construct(T)
{
	T t;
	this(Q)(Q q)
	{
		static if(is(Q : T))
		{
			t = q;
		}
		else
		{
			this.t = T(q);
		}
	}
}

struct Data
{
	string s;
}

void f(Construct!Data xC ...) //construct the wrapper class
{
	auto x = xC.t; //get the contents.
	
	import std.stdio;
	writeln(x.s);
}

void main()
{
	f("hello");
	f(Data("world"));
}


Overall it's probably best to define f as:

void f(Data x)
{
	import std.stdio;
	writeln(x.s);
}

void f(Construct!Data xC ...)
{
	.f(xC.t);
}

To avoid any overhead when calling normally as well as separating 
the definition of the real function from the concern of automatic 
construction/conversion.