I'm obviously doing something wrong, but don't quite understand.

mixin template helper() {
  mixin("writeln(12);");
}

struct Foo {
  void opDispatch(string name)() {
    import std.stdio;
    mixin helper!();
    //mixin("writeln(12);");
  }
}

void main() {
  Foo.init.opDispatch!"bar"();
}

The compiler emits these errors about the mixin ("writeln(12);"):
unexpected ( in declarator
basic type expected, not 12
found 12 when expecting )
no identifier for declarator writeln(_error_)
semicolon expected following function declaration
declaration expected, not )

Why does the commented code work but the mixin not? Thanks for any pointers.

On Thursday, 12 January 2023 at 08:03:34 UTC, John Chapman wrote:

mixin template helper() {
  mixin("writeln(12);");
}

struct Foo {
  void opDispatch(string name)() {
    import std.stdio;
    mixin helper!();
    //mixin("writeln(12);");
  }
}

void main() {
  Foo.init.opDispatch!"bar"();
}

mixin template cannot be used like that. The only statement it accepts are declaration statements: Look at https://dlang.org/spec/module.html#MixinDeclaration

It says it must compile to a valid DeclDef, which means you can't put code like that.

Mixin templates are used only for declaring new variables, types and functions, it can't simply put call statements like that. You could do this by simply calling a function such as:

void helper()
{
    writeln(12);
}

I think you'll need to comment more on your problem if you wish specialized help

On Thursday, 12 January 2023 at 08:03:34 UTC, John Chapman wrote:

mixin template helper() {
  mixin("writeln(12);");
}

struct Foo {
  void opDispatch(string name)() {
    import std.stdio;
    mixin helper!();
    //mixin("writeln(12);");
  }
}

void main() {
  Foo.init.opDispatch!"bar"();
}

Mixin templates cannot have statements directly, so you need two changes for your code to work:

1. Change your mixin template to something like this:

mixin template helper() {
    // we place the statements in this function instead
    void helper() {
        mixin("writeln(12);");
    }
}

2. Change the place where you instantiate to this:

struct Foo {
  void opDispatch(string name)() {
    import std.stdio;
    mixin helper!();
    helper(); // calling the function in the mixin template
  }
}

On Thursday, 12 January 2023 at 08:03:34 UTC, John Chapman wrote:

Why not directly use the mixin template for opDispatch()?

mixin template helper() {
  void opDispatch(string name)() {
    import std.stdio;
    writeln(12);
  }
}

struct Foo {
  mixin helper;
  // ...
}

void main() {
  Foo.init.opDispatch!"bar"();
}

SDB@79

On Friday, 13 January 2023 at 14:32:44 UTC, Salih Dincer wrote:

My opDispatch generates code based on the arguments passed, interpolating variable names and functions based on the type. I wanted to remove the double braces in my static foreach (needed as I declared some aliases inside but since it creates a scope those new variables can't be referred to outside of it). I saw Adam's post here http://dpldocs.info/this-week-in-d/Blog.Posted_2022_12_26.html showing use of a "helper" template, and I was trying to adapt it.

I've since just dropped the double braces and removed the aliases. It's not as clean but works.

On Thursday, 12 January 2023 at 08:03:34 UTC, John Chapman wrote:

mixin template helper() {
  mixin("writeln(12);");
}

struct Foo {
  void opDispatch(string name)() {
    import std.stdio;
    mixin helper!();
    //mixin("writeln(12);");
  }
}

void main() {
  Foo.init.opDispatch!"bar"();
}

This is not the purpose mixin templates are meant to serve. They're for copying declarations into scopes (and as such only support declarations in them). Instead, I think what you want is

template helper() {
	const char[] helper = `writeln(12);`;
}

struct Foo {
	void opDispatch(string name)() {
		import std.stdio;
		mixin(helper!());
	}
}

void main() {
	Foo.init.opDispatch!"bar"();
}

On Saturday, 14 January 2023 at 18:57:21 UTC, John Chapman wrote:

Inside a function, you can often just use plain foreach instead of static foreach and simplify things. But it depends on the whole context.

Where the helper thing helps a lot is outside functions, where normal foreach and double brace are both prohibited.