The return type of the function is an awkward expression, and it has to be repeated to define Result. I’m in a similar situation, where I’d like to capture the return type but I have to duplicate a type expression.
I’m hoping there’s something like @Func that will return a useful handle that can be queried?
As with many things Zig, this isn’t builtin, but you can make it yourself. mlugg supplied this useful bit of code on discord not long ago for a similar purpose:
fn ErrorReturn(comptime T: type) type {
const Ret = @typeInfo(T).Fn.return_type.?;
return @typeInfo(Ret).ErrorUnion.error_set;
}
So while you might have to keep something like Min(@TypeOf(x), ...) in the function declaration I believe you’ll have no trouble making a helper function with a short name that takes @TypeOf(func) as a parameter and returns its return_type to grab that for your Result.
Indeed. The type of min( param1, ... ) T { is fully and completely defined by T there, so you have to make it anytype at the very least. Everything after that can use the function’s return type.
Beware that the @TypeOf(min) is a function type, not a return type.
So this is an unsolved problem as I thought. I deal with it by avoiding anytype and using the comptime T: type style instead. The min function is unusual in that it’s combining two types, usually the situation is simpler.
This is not likely an unsolved problem. To be clear, the min function is taking the minimum of two values. The Min function is declared with pub fn Min(comptime A: type, comptime B: type) type {, but is useless for processing non-type values.
The return type of min is exposed with @typeInfo(@TypeOf(min)).Fn.returntype.?. Of course, that is a bit of a mouthful, so that can be shorted by putting that in a function that takes @TypeOf(min) as a parameter.
It seems there is no convenient way to grab the outer function, except by copying the name.
I have written a helper function to take a function and return the return type:
fn ReturnType(comptime func: anytype) type {
if (@typeInfo(@TypeOf(func)) != .Fn) {
@compileError("Argument 1 (func) to ReturnType must be a function");
}
return @typeInfo(@TypeOf(func)).Fn.return_type.?;
}
test "ReturnType" {
// _ = ReturnType(1);
}
I think we posted at the same time. Your ReturnType function works, but unfortunately not in the case you want it to, which is for generic functions. The return_type field is optional because it is null for generic functions. I had forgotten this and rediscovered it during this conversation!
Oh, I’m more than a little silly here. Grabbing the function by name, as I was intending to do, won’t help because the function doesn’t return any particular type until it is called with a type, even within the scope of the function itself. So getting the actual function after the compiler determines its types is tricky enough that you can’t actually pass it to @TypeOf in the first place.
I was able to pass the function name to @TypeOf in the body … but the return_type and arg_type of the anytype params were all null, so you’re right that there is no value in doing this.
My rule of thumb is to stick to simple use of generics in Zig, and wait to see how this part of the language evolves. It works really well you have a T type param and you keep things simple.
So getting the actual function after the compiler determines its types is tricky enough that you can’t actually pass it to @TypeOf in the first place.
I was able to pass the function name
Right, I may have edited my post to clarify. In any case, as you said, the way to avoid duplicating the type expression in the function call atm appears to be to be explicit about the type everywhere you call it, which may or may not be less burdensome:
