Of course for plain compilers var parameters can be faster, because without smart optimizations result objects can be first allocated on the proc stack and then copied back to the caller variable. But I had the strong feeling that this optimization is generally done, so I never tried to avoiding result parameters. But my current observation is that a var parameter can be indeed faster, by 10 to 20 % in my test case. (I discovered that fact by tuning my chess engine, so it is a real life observation...)
import random, times type Data = tuple a: array[16, int] age: int proc p1(): Data = for i in mitems(result.a): i = random(7) result.age = random(7) proc p2(res: var Data) = for i in mitems(res.a): i = random(7) res.age = random(7) proc main = var h: Data var sum: int var t: float # cpuTime() t = cpuTime() for x in 0 .. 9999: h = p1() sum += h.age echo sum echo "p1: ", cpuTime() - t t = cpuTime() for x in 0 .. 9999: p2(h) sum += h.age echo sum echo "p2: ", cpuTime() - t main() # $ nim c -d:release ups.nim # ~/nim-chess2 $ ./ups # 29915 # p1: 0.000519 # 60011 # p2: 0.00042
Isn't tuple assignment by copy? That's probably the difference.
The optimization that Nim can make is to pass the function arguments by reference. Maybe try an example which passes the result of p1() directly to a function that takes a tuple. I suspect there would be no runtime difference in that case.