www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Nested template arguments

reply XavierAP <n3minis-git yahoo.es> writes:
Why

	foo!bar!x

is not understood as

	foo!(bar!x)

but instead gives an error "multiple ! arguments are not allowed"?
Precisely because multiple "!" can never belong to the same 
instantiation, why does the parser not understand without needing 
brackets that the rightmost template should be nested as the 
argument for the next one to the left?
Aug 22 2018
parent reply Alex <sascha.orlov gmail.com> writes:
On Wednesday, 22 August 2018 at 14:30:39 UTC, XavierAP wrote:

 Why

 	foo!bar!x

 is not understood as

 	foo!(bar!x)

 but instead gives an error "multiple ! arguments are not 
 allowed"?
 Precisely because multiple "!" can never belong to the same 
 instantiation, why does the parser not understand without 
 needing brackets that the rightmost template should be nested 
 as the argument for the next one to the left?


Because it could be meant as the argument to some templates to 
the left. Like
(foo!bar)!x

Sure, it would be a coincidence, if both will work. However, 
templates are not something where you can simply imply the 
associative property, I think.
Aug 22 2018
parent reply XavierAP <n3minis-git yahoo.es> writes:
On Wednesday, 22 August 2018 at 14:48:57 UTC, Alex wrote:

 Because it could be meant as the argument to some templates to 
 the left. Like
 (foo!bar)!x

 Sure, it would be a coincidence, if both will work. However, 
 templates are not something where you can simply imply the 
 associative property, I think.


Of course there isn't an associative property... But I was 
thinking that without brackets the parser could fall back to 
whatever default "left to right" precedence, as would happen with 
operators, which needn't be associative either.
Aug 22 2018
parent reply Alex <sascha.orlov gmail.com> writes:
On Wednesday, 22 August 2018 at 15:18:29 UTC, XavierAP wrote:

 On Wednesday, 22 August 2018 at 14:48:57 UTC, Alex wrote:

 Because it could be meant as the argument to some templates to 
 the left. Like
 (foo!bar)!x

 Sure, it would be a coincidence, if both will work. However, 
 templates are not something where you can simply imply the 
 associative property, I think.


 Of course there isn't an associative property... But I was 
 thinking that without brackets the parser could fall back to 
 whatever default "left to right" precedence, as would happen 
 with operators, which needn't be associative either.


Ah... ok. Got your idea. No. This isn't possible because some 
symmetry of the operator is implied.

https://wiki.dlang.org/Operator_precedence

Chaining is explicitly not allowed, like in comparison operators 
:)
Aug 22 2018
parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 8/22/18 11:37 AM, Alex wrote:

 On Wednesday, 22 August 2018 at 15:18:29 UTC, XavierAP wrote:

 On Wednesday, 22 August 2018 at 14:48:57 UTC, Alex wrote:

 Because it could be meant as the argument to some templates to the 
 left. Like
 (foo!bar)!x

 Sure, it would be a coincidence, if both will work. However, 
 templates are not something where you can simply imply the 
 associative property, I think.


 Of course there isn't an associative property... But I was thinking 
 that without brackets the parser could fall back to whatever default 
 "left to right" precedence, as would happen with operators, which 
 needn't be associative either.


 
 Ah... ok. Got your idea. No. This isn't possible because some symmetry 
 of the operator is implied.
 
 https://wiki.dlang.org/Operator_precedence
 
 Chaining is explicitly not allowed, like in comparison operators :)


Note that Instantiate in std.meta exists to overcome this limitation:

Instantiate!(foo!bar, x);

-Steve
Aug 23 2018