On Tuesday, 6 July 2021 at 14:27:35 UTC, Paul Backus wrote:
Instead of having the template evaluate to a `bool`, have it
evaluate to the type of the result:
```d
alias ResultType(Lhs, string op, Rhs) =
typeof(((Lhs lhs, Rhs rhs) => mixin("lhs", op, "rhs"))());
static assert(is(ResultType!(int, "+", double) == double));
static assert(is(ResultType!(string, "~", string) == string));
static assert(!is(ResultType!(string, "+", int))); // no valid
result type
```
Then you can use `is()` in the template constraints to check
whether the operation is supported:
```d
auto opBinary(string op, Rhs: T2[], T2) const
if (is(ResultType!(T, op, T2)))
{
Vec!(ResultType!(T, op, T2), L) result;
// etc.
}
```
Oh that's neat, thanks.
I guess that would make it:
```d
auto opBinary(string op, R)(R right) const if (is(ResultType!(T,
op, R))) {
Vec!(ResultType!(T, op, R), L) result;
static foreach (i; 0 .. L) {
mixin("result[i] = this[i] " ~ op ~ " right;");
}
return result;
}
```
I guess I'll just have to take the result definition for what it
is. At least the return type can use auto, haha. Imagine using
ResultType!(T, op, R) thrice...
Is there any reason the function call in the alias is acceptable?
I would imagine the () part would actually require 2 parameters.
