Optional parameters?

[Seb]

On Sunday, 1 April 2018 at 15:54:16 UTC, Steven Schveighoffer 
wrote:
> I currently have a situation where I want to have a function 
> that accepts a parameter optionally.
>
> I thought maybe Nullable!int might work:
>
> void foo(Nullable!int) {}
>
> void main()
> {
>    foo(1); // error
>    int x;
>    foo(x); // error
> }
>
> Apparently, I have to manually wrap an int to get it to pass. 
> In other languages that support optional types, I can do such 
> things, and it works without issues.
>
> I know I can do things like this:
>
> void foo(int x) { return foo(nullable(x)); }
>
> But I'd rather avoid such things if possible. Is there a way 
> around this? Seems rather limiting that I can do:
>
> Nullable!int x = 1;
>
> but I can't implicitly convert 1 to a Nullable!int for function 
> calls.
>
> -Steve

My workaround is to use struct initialization:

---
import std.stdio, std.typecons;

static struct FooConfig
{
     Nullable!int a;
}

void foo(FooConfig optionalConfig = FooConfig.init)
{
     optionalConfig.writeln;
}

void main()
{
     foo();

     FooConfig params = {
        a: 42,
     };
     foo(params);
     //foo(FooConfig(42)); // <- hehe, no implicit conversion
}
---

https://run.dlang.io/is/HvN701

I know the separate line and variable is annoying.
With the in-place struct-initialization DIP 
(https://github.com/dlang/DIPs/pull/71), it would become sth. 
like:

foo(FooConfig({a : 42}));
foo(FooConfig{a : 42});

(syntax is not clear yet and I still haven't gotten around 
implementing this in DMD)