Get union value type by enum

[nexus_prime]

pub const Node = struct {
	kind: Kind,
    props: Props

	pub fn init(comptime kind: Kind, prop: ?) void {

	}

	pub const Kind = enum {
		A,
		B,
		C
	};

	pub const Props = union(Kind) {
		A: A,
		B: B,
		C: C,
	} ;

	pub const A = struct {
		
	};
	pub const B = struct {

	};
	pub const C = struct {

	};
};

Can i get the struct of prop by kind type?

I thought use it like:

Node.init(.A, .{})

I already tried:

pub fn init(comptime kind: Kind, prop: @TypeOf(@field(Props, @tagName(kind))))

[Sze]

I think you are looking for std.meta.TagPayload here are some examples that use it:

Can I allocate only the required amount of memory for tagged unions?

Here are some suggestions: using @unionInit, std.meta.TagPayload and std.meta.Child using switch with inline else avoiding the arena (often better to first make sure your program works without an arena too, if your alloc always needs to be an arena, then call it arena or arena_alloc?) const std = @import("std"); const Node = union(enum) { const Tag = std.meta.Tag(Node); Foo: *struct { shared: u8, text: []const u8 }, Bar: *struct { shared: u8, num: f64 }, pub fn Value(compti…

Tagged union with comptime tag

I am not quite sure whether this is what you want. What you write sounds like you want to generate separate functions at compile time. To me that seems like overkill, I think using the log function in my example below, with the tag would satisfy me. If you really want to use separate functions, I think you would need to generate source code at build time. (I am not completely sure on that, but it seems to me, that you can’t easily generate completely new function declarations with comptime) …

[LucasSantos91]

Is this what you wanted?

pub fn init(prop:  Props) Node {
 return .{ .kind = props };
}

A tagged union coerces into the tag type.

[nexus_prime]

thanks, TagPayload will work on my case