| |
| Posted by Simen Kjærås in reply to XavierAP | PermalinkReply |
|
Simen Kjærås
Posted in reply to XavierAP
| On Thursday, 9 May 2019 at 09:52:21 UTC, XavierAP wrote:
> What are the benefits of alias parameters, compared to specifying the template parameters fully?
> https://dlang.org/spec/template.html#aliasparameters
>
> In most examples, at places in Phobos, and in Andrei's and Ali’s books, alias parameters are used for functions (in the general sense). Why this instead of specifying and typing the parameter functions or delegates?
Genericity, for one. This code will work with functions, delegates, templated functions, lambdas, and functors:
void call(alias fun)() {
fun();
}
> This brings another question, why is it so widespread in Phobos etc. to template these function parameters instead of declaring them as run-time parameters? Is this really always considered beneficial, why?
The compiler can optimize calls to compile-time parameters, but not run-time parameters. Also, as said above, alias parameters support a greater variety of types. If instead run-time parameters were used there'd have to be multiple overloads, or a templated function that accepts all the different callables.
> For one it looks like it saves a lot of typing and makes the whole declaration more readable (not to mention possible attribute soups); but the type-checking code just moves to additional template constraints.
The type checking tends to be a lot looser though - more along the lines of 'Can I call f with these parameters?', rather than 'Is f a function taking two ints and a string, returning a bool, and adorned with @safe and @nogc?'. There are tradeoffs there, of course, and you should use whichever is more correct for your use case.
> And finally what’s the advantage of alias parameters in general, besides function/delegates? But I don’t see other uses in practice, although they’re possible.
Templates can be passed in alias parameters. This is used quite extensively in std.meta. In fact, alias parameters accept anything* with a name. This makes it easy to build templates that operate on any type or scope (e.g. a module) with the exact same code, and passing them from one template to the other without having to rewrite them to operate on specific types of objects.
Another use case is to pass a value of an unknown type. Without alias parameters, you'd have to pass the type as well, something like foo!(int, 3) instead of foo!3, or use a template sequence parameter and a template constraint:
template foo(Value...) if (Value.length == 1) {}
This is clearly untenable for more than a single such parameter.
In my own code, I've almost exclusively used alias parameters for templates, with functions being the second most common, and one or two examples of the module/types mentioned above.
* except built-in primitive types
--
Simen
|