www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Are templated functions always re-constructed?

reply rempas <rempas tutanota.com> writes:
Let's say that I have the following function:

```
void add(T)(T val, T val2) { return val + val2; } // Classic 
example, lol
```

Now let's say that I call the function passing an `int` 
parameter. The function will get built with an `int` type. What 
happens the second time that I will call it again? Will it get 
the already build function or will it make a new one? I suppose 
it re-uses it but still I wanted to ask just in case. Please only 
answer if you are sure and not be making guesses because it is 
really important! Thanks!
Nov 16 2021
next sibling parent reply "H. S. Teoh" <hsteoh quickfur.ath.cx> writes:
On Tue, Nov 16, 2021 at 09:14:50PM +0000, rempas via Digitalmars-d-learn wrote:

 Let's say that I have the following function:
 
 ```
 void add(T)(T val, T val2) { return val + val2; } // Classic example, lol
 ```
 
 Now let's say that I call the function passing an `int` parameter. The
 function will get built with an `int` type. What happens the second
 time that I will call it again? Will it get the already build function
 or will it make a new one? I suppose it re-uses it but still I wanted
 to ask just in case. Please only answer if you are sure and not be
 making guesses because it is really important! Thanks!


Short answer: a template called with the same CT arguments will only be
instantiated once, and reused thereafter.

Long answer: the above applies per compilation. If you compile your
sources separately, there may be multiple instantiations of the template
with the same CT arguments.  However, unless something went wrong, these
duplicates will be dropped by the linker.


T

-- 
Making non-nullable pointers is just plugging one hole in a cheese grater. --
Walter Bright
Nov 16 2021
parent reply rempas <rempas tutanota.com> writes:
On Tuesday, 16 November 2021 at 21:30:08 UTC, H. S. Teoh wrote:

 Short answer: a template called with the same CT arguments will 
 only be instantiated once, and reused thereafter.

 Long answer: the above applies per compilation. If you compile 
 your sources separately, there may be multiple instantiations 
 of the template with the same CT arguments.  However, unless 
 something went wrong, these duplicates will be dropped by the 
 linker.


 T


Thanks! I mostly care about compilation times rather than 
duplication tbh
Nov 17 2021
parent reply "H. S. Teoh" <hsteoh quickfur.ath.cx> writes:
On Wed, Nov 17, 2021 at 11:12:22AM +0000, rempas via Digitalmars-d-learn wrote:

 On Tuesday, 16 November 2021 at 21:30:08 UTC, H. S. Teoh wrote:

 
 Short answer: a template called with the same CT arguments will only
 be instantiated once, and reused thereafter.
 
 Long answer: the above applies per compilation. If you compile your
 sources separately, there may be multiple instantiations of the
 template with the same CT arguments.  However, unless something went
 wrong, these duplicates will be dropped by the linker.




[...]

 Thanks! I mostly care about compilation times rather than duplication
 tbh


Regular (non-recursive) templates generally will not cause a noticeable
change in compilation times.  The trouble usually only starts when you
start using recursive templates.  Or when your templates are nested
unreasonably deep (though this also usually only happens when there's
recursive instantiation somewhere).


T

-- 
Computerese Irregular Verb Conjugation: I have preferences.  You have biases. 
He/She has prejudices. -- Gene Wirchenko
Nov 17 2021
parent rempas <rempas tutanota.com> writes:
On Wednesday, 17 November 2021 at 17:02:45 UTC, H. S. Teoh wrote:

 Regular (non-recursive) templates generally will not cause a 
 noticeable change in compilation times.  The trouble usually 
 only starts when you start using recursive templates.  Or when 
 your templates are nested unreasonably deep (though this also 
 usually only happens when there's recursive instantiation 
 somewhere).


 T


That's awesome! Thanks!
Nov 19 2021
prev sibling parent reply Mike Parker <aldacron gmail.com> writes:
On Tuesday, 16 November 2021 at 21:14:50 UTC, rempas wrote:

 Let's say that I have the following function:

 ```
 void add(T)(T val, T val2) { return val + val2; } // Classic 
 example, lol
 ```

 Now let's say that I call the function passing an `int` 
 parameter. The function will get built with an `int` type. What 
 happens the second time that I will call it again? Will it get 
 the already build function or will it make a new one? I suppose 
 it re-uses it but still I wanted to ask just in case. Please 
 only answer if you are sure and not be making guesses because 
 it is really important! Thanks!


You might find this useful:

https://dlang.org/blog/2020/07/31/the-abcs-of-templates-in-d/
Nov 16 2021
parent rempas <rempas tutanota.com> writes:
On Wednesday, 17 November 2021 at 02:50:43 UTC, Mike Parker wrote:

 You might find this useful:

 https://dlang.org/blog/2020/07/31/the-abcs-of-templates-in-d/


I do! Thanks a lot!
Nov 17 2021