All the stuff I've read about templates always refers to them as template declarations.

So with the following code segment:

template codeBlockTemplate(T, U)
{
    T a = 7;
    U b = 'z';
}

codeBlockTemplate!(int, char);  // error here

Microsof's Visual Studio IDE tells me <identifier> expected, ; found

But aren't templates instantiated at compile time? If so, isn't memory allocated at compile time, so in theory couldn't templates support code definitions?


Bonus question: Isn't a Zero-parameter template declaration pretty much worthless?

Thanks.

On Tuesday, 30 June 2015 at 21:06:58 UTC, WhatMeWorry wrote:
> All the stuff I've read about templates always refers to them as template declarations.
>
> So with the following code segment:
>
> template codeBlockTemplate(T, U)
> {
>     T a = 7;
>     U b = 'z';
> }
>
> codeBlockTemplate!(int, char);  // error here
>
> Microsof's Visual Studio IDE tells me <identifier> expected, ; found
>
> But aren't templates instantiated at compile time? If so, isn't memory allocated at compile time, so in theory couldn't templates support code definitions?

I'm having trouble understanding the question/problem, but maybe you're looking for `mixin`:

mixin codeBlockTemplate!(int, char);

>
>
> Bonus question: Isn't a Zero-parameter template declaration pretty much worthless?

Pretty much, yeah. A function with an empty body is pretty much worthless, too. I see no point in adding extra logic to forbid them, though. They don't do any harm and there are probably cases when it'd be annoying were they forbidden.

I was reading "D Templates: A Tutorial" by Philippe Sigaud which says:

--------------------------- quote
What is a Template? In the next chapters, you’ll see how to define function, struct and class templates.

But before that, I’d like to introduce what a template really is, because this
definition is the most fundamental of the whole document. As I said, a template
is a way to define a blueprint to generate some code, be it a class definition, a
function or. . . what? What could be the most abstract unit of code?

But where is the basic unit to hold this code? Well, a code block of course, or a
scope.

This is what a template is, at its core: a named, parameterized,
code block, ready to be instantiated just for you.
--------------------------- end quote


so thinking that I had reached a first principle, I wrote the above template.
But then when this failed to compile, I then read further and it says:


--------------------------- quote
Template Declarations

Here is the syntax for a template declaration:

template templateName(list, of, parameters)
{
    // Some syntactically correct declarations here
    // The arguments are accessible inside the template scope.
}
--------------------------- end quote

so the code block must consist only of declarations.  Which lead to me to ask my original question.

mixins could work but I'm just trying to understand templates and this particular limitation.

On Tuesday, 30 June 2015 at 21:06:58 UTC, WhatMeWorry wrote:
> Bonus question: Isn't a Zero-parameter template declaration pretty much worthless?

Functions in templates get certain attributes inferred automatically, like `@nogc`, `pure`, `nothrow`, `@safe`. Some people use them for that purpose. (Because of IFTI, functions with empty template parameters can be called with the same syntax as normal functions, they don't need the `!()`.)

On Wednesday, July 01, 2015 09:29:56 via Digitalmars-d-learn wrote:
> On Tuesday, 30 June 2015 at 21:06:58 UTC, WhatMeWorry wrote:
> > Bonus question: Isn't a Zero-parameter template declaration pretty much worthless?
>
> Functions in templates get certain attributes inferred automatically, like `@nogc`, `pure`, `nothrow`, `@safe`. Some people use them for that purpose. (Because of IFTI, functions with empty template parameters can be called with the same syntax as normal functions, they don't need the `!()`.)

That and it lets you use auto ref. It also can be necessary when overloading templated functions. It used to be that you couldn't overlooad a templated function with a non-templated function, forcing you to have functions with no template parameters if you wanted to have what would normally be a non-templated function overload a templated function. That's now been fixed, but the overload rules aren't quite the same between a non-templated functions and a templated function with no parameters, so sometimes you still need to templatize a function with empty parameters depending on what you're trying to do with your function overloads.

- Jonathan M Davis