https://docarchives.dlang.io/v2.073.0/spec/struct.html#struct-literal

I would like to set function's default struct for a function in a way that it would be visible for the reader to see what options are set. Something like Options option = {silenceErrors: false}

Here is an example of what I would hope for to work but it surely does not work:

import std.stdio;

struct Options {
    bool silenceErrors = false;
}

void someFunction(Options option = {silenceErrors: false}){
	writeln(option);

}

void main() {
	someFunction();
}

Is it possible to make this part work in a simple way, maybe I'm using a wrong syntax here?

void someFunction(Options option = {silenceErrors: false}){
	writeln(option);

}

On Monday, 11 September 2023 at 17:51:04 UTC, BoQsc wrote:

If I were you I would use enum, look at my code:

enum Options
{
  silenceErrors = false
}

void someFunction (Options option = Options.silenceErrors)
{
  writeln(cast(bool)option); // false
}

import std.stdio;
void main()
{
  someFunction();
}

SDB@79

On Monday, 11 September 2023 at 17:51:04 UTC, BoQsc wrote:

import std.stdio;

struct Options {
    bool silenceErrors = false;
}

void someFunction(Options option = {silenceErrors: false}){
	writeln(option);

}

void main() {
	someFunction();
}

void someFunction(Options option = {silenceErrors: false}){
	writeln(option);

}

I would love to be able to use C style designated initialization everywhere too..

Recent version of D added named arguments so you can do something like:

void someFunction(Options option = Options(silenceErrors: false))

I don't like the useless repeating "option option option", but that's D for you

On Monday, 11 September 2023 at 20:17:09 UTC, H. S. Teoh wrote:

Why not allow it to be flexible enough by using a template parameter?

enum Options : bool
{
  silenceErrorsOff, silenceErrorsOn
}

struct Opts
{
  bool silenceErrors;
}

void someFunction(T)(T option = T())
{
  import std.stdio;
  writeln(cast(bool)option); // true
}

void main()
{
  Opts o;
  someFunction(o.silenceErrors = true);

  with(Options)
  someFunction(silenceErrorsOn);
}

SDB@79

On Monday, 11 September 2023 at 22:13:25 UTC, H. S. Teoh wrote:

it's possible...

alias ST = Options;
void specificType(ST option = ST())
{
  if(option)
  {
    assert(false);
  } else
    assert(true);
}

void main()
{
  specificType(); // No error
  specificType(ST.silenceErrorsOn); // assert failure
}

SDB@79

On Monday, 11 September 2023 at 19:59:37 UTC, ryuukk_ wrote:

void someFunction(Options option = Options(silenceErrors: false))

void someFunction(bool silenceErrors = false, bool otherOption = true)

someFunction(otherOption: false); // works

I know options structs have benefits besides allowing parameter specification, but with the latest allowance of named parameters, it's worth exploring whether you still want to use an options struct or not.

-Steve

On Monday, 11 September 2023 at 17:51:04 UTC, BoQsc wrote:

If the function's defaults will always match the default initializers of the struct itself,

struct Options {
    bool silenceErrors = false;
}
void someFunction(Options option = Options.init) {
	writeln(option);
}

else:

struct Options {
    bool silenceErrors = false;
}
void someFunction(Options option = Options(silenceErrors: true)) {
	writeln(option);
}