Error when tuple fields have the same names as template parameters.

[ReneSac]

I can't use the tuple constructor in this case:

type Foo = tuple
  p, n: int

template t(p, n:int): Foo = (p: p, n: n) 

echo t(3,3)  # Error: named expression expected

Neither initialize the fields separatedly:

type Foo = tuple
  p, n: int

template t(p, n:int): Foo = 
  var res: Foo
  res.p = p
  res.n = n
  res  # I'm not sure if it is needed for returning correctly

echo t(3,3)  # Error: identifier expected, but found '3'

This forces the interface of the template (if using named parameters) to be different than the type/tuple interface (getting field values).

[fowlmouth]

This is what templates do..

template getField(obj, field): expr =
  obj.field
echo getField((x: 1, y: 2), x)

If you need to access fields p and n then you cannot use those names for your arguments

[zah]

fowl is right, this behavior is on purpose.

Here is some code that will work:

type Foo = tuple
  p, n: int

template t(pp, nn: int): Foo = (p: pp, n: nn)

echo t(3,3)

[ReneSac]

It would be good if there were an specific type for passing a field name. I want to pass integers, and integers can never be a field name. Would a specific type for receiving field names limit that usage you showed?

[Araq]

This seems like a good solution except for the fact that the parameter's types do not influence symbol binding rules in templates ...

[ReneSac]

This is by design or something that should be fixed/improved eventually?

[Araq]

Symbol binding rules are already complex enough, so please leave it as it is. Just use a proc. There is a reason 'proc' is shorter than 'template'...

[ReneSac]

A simple proc can't really do all I need. Python uses code as strings and eval() for that (poors man template)... For now I will use different names for the parameters then, as this seems hard to solve.

But even if it isn't a priority, it would be good if this could be fixed in the future w/o breaking backwards compatibility. Maybe introducing that said 'field name' type, even if not using it keeps the current behavior for now.

[reactormonk]

Can you post sample code where you need that template?

[dom96]

I would prefer if templates didn't do this sort of thing implicitly. Would introducing an operator be as complicated as what @ReneSac suggested?

Something like:

type Foo = tuple
  p, n: int

template t(fieldname: expr, val: int): Foo =
  result.!fieldname = val

echo t(p,3)