求值顺序

求值顺序严格从左到右，由内到外，这是大多数其他强类型编程语言的典型做法:

  1. var s = ""
  3. proc p(arg: int): int =
  4.   s.add $arg
  5.   result = arg
  7. discard p(p(1) + p(2))
  9. doAssert s == "123"

赋值也不特殊，左边的表达式在右边的表达式之前被求值:

  1. var v = 0
  2. proc getI(): int =
  3.   result = v
  4.   inc v
  6. var a, b: array[0..2, int]
  8. proc someCopy(a: var int; b: int) = a = b
  10. a[getI()] = getI()
  12. doAssert a == [1, 0, 0]
  14. v = 0
  15. someCopy(b[getI()], getI())
  17. doAssert b == [1, 0, 0]

原由：与重载赋值或类似赋值的运算符保持一致，a = b 可以理解为 performSomeCopy(a, b) 。

然而，”求值顺序” 的概念只有在代码被规范化之后才适用。规范化涉及到模板的扩展和参数的重新排序，这些参数已经被传递给命名参数。

  1. var s = ""
  3. proc p(): int =
  4.   s.add "p"
  5.   result = 5
  7. proc q(): int =
  8.   s.add "q"
  9.   result = 3
  11. # 由于模板扩展语义，求值顺序是 'b' 在 'a' 之前。
  12. template swapArgs(a, b): untyped =
  13.   b + a
  15. doAssert swapArgs(p() + q(), q() - p()) == 6
  16. doAssert s == "qppq"
  18. # 求值顺序不受命名参数的影响:
  19. proc construct(first, second: int) =
  20.   discard
  22. # 'p' 在 'q' 之前求值!
  23. construct(second = q(), first = p())
  25. doAssert s == "qppqpq"

原由: 这比其他设想的替代方案容易实现。