Hello,
I am trying to derive a struct from another. I want to modify each field such that type of it goes from some T to Nullable!T, preserving all fieldnames and UDAs.

I think that fieldnames and UDAs can only be duplicated via string-mixins. This means that all field-types that aren't visible in the template scope have to first be aliased to some name that can be referenced in the string mixin. I got this to work for simple types, but as soon as the field types are some templated type, doing this naively stops to work.
Same story for UDAs. As soon as multiple unknown types are involved, I can't simply take an alias anymore.

The one workaround I found is to make my introspective struct part of a template mixin, this way it can access all symbols of the callsite and can use all the symbols. Is this the recommended way to do it? Generating a string mixin directly would probably work just as well, but that seems even more ugly and will probably be more susceptible to collisions.

This not so simple gist demonstrates what I tried so far. injectedNameFields generates a string that when mixed in, will create all the field names with the desired types. I suggest first looking at main and compiling+running to get an idea what is supposed to happen.
https://gitlab.com/-/snippets/3687470

After describing my problem, here is a non-exhaustive list of questions I have:

• Is UDA propagation possible without string mixins?
• To make it run without template mixin, I will need to write a recursive template (recursive over template args as well as UDA instantiated structs) that accounts for cases: normal type, templated type, enum (C style), enum value compile time constant, etc. ... Is this correct, or is there a way to just grab any compile time alias/enum without giving each "type" special treatment?
• Are template mixins vulnerable to name collisions?

On Thursday, 14 March 2024 at 23:19:37 UTC, Inkrementator wrote:

This is trivially easy if your types are visible at module level, and mixin is a fine tool for the job. It doesn't work quite so well with Voldemort types.

struct MyUDA { int q; }
struct Foo { int f; }
struct MyStruct {
	@MyUDA(3) int x;
	@MyUDA(4) Foo f;
	@MyUDA(5) @MyUDA(7) string s;
}
auto generateUDAs(A...)() {
	string[] udaStrs;
	static foreach (uda; A)
		udaStrs ~= "@(" ~ uda.stringof ~ ")";
	return udaStrs;
}
struct Wrapped(S) {
	static foreach (idx, field; S.tupleof) {
		//pragma(msg, format(... can be used to preview
		mixin(format("%s %s %s;", generateUDAs!(__traits(getAttributes, field)).join(' '), Nullable!(typeof(field)).stringof, field.stringof));
	}
}
void main() {
	MyStruct s;
	s.x = 3;
	s.f = Foo(1);
	s.s = null;
	Wrapped!MyStruct w;
	w.x = s.x;
	w.f = s.f;
	w.s = s.s;
	w.x.nullify;
	w.f.nullify;
	w.s.nullify; // strings/objects are already nullable though
	static assert(__traits(getAttributes, w.s) == AliasSeq!(MyUDA(5), MyUDA(7)));
}

If you absolutely must though, you could do something like

enum WrapMixin = q{
	struct Wrapped(S) {
		static foreach (field; S.tupleof)
			mixin(format("%s %s %s;", generateUDAs!(__traits(getAttributes, field)).join(' '), Nullable!(typeof(field)).stringof, field.stringof));
	}
};
void main() {
	struct MyUDA { .....
	struct MyStruct { .....
	mixin(WrapMixin);
	Wrapped!MyStruct w;
}

On Friday, 15 March 2024 at 19:13:38 UTC, cc wrote:

static foreach(att; allFieldTypes){
			//pragma(msg, "alias %s =att;\n".format(att.stringof));
			mixin("alias %s = att;\n".format(att.stringof));
		}

But I don't know how to do this (in a general) for UDAs, since they can be values instead of types too, i.e. @UDA(Voldemort!2(3))