EffectsOf annotation

Rules 1-2 of the exception tracking inference rules (see the previous section) ensure the following works:

proc weDontRaiseButMaybeTheCallback(callback: proc()) {.raises: [], effectsOf: callback.} =
  callback()
proc doRaise() {.raises: [IOError].} =
  raise newException(IOError, "IO")
proc use() {.raises: [].} =
  # doesn't compile! Can raise IOError!
  weDontRaiseButMaybeTheCallback(doRaise)

As can be seen from the example, a parameter of type proc (…) can be annotated as .effectsOf. Such a parameter allows for effect polymorphism: The proc weDontRaiseButMaybeTheCallback raises the exceptions that callback raises.

So in many cases a callback does not cause the compiler to be overly conservative in its effect analysis:

{.push warningAsError[Effect]: on.}
import algorithm
type
  MyInt = distinct int
var toSort = @[MyInt 1, MyInt 2, MyInt 3]
proc cmpN(a, b: MyInt): int =
  cmp(a.int, b.int)
proc harmless {.raises: [].} =
  toSort.sort cmpN
proc cmpE(a, b: MyInt): int {.raises: [Exception].} =
  cmp(a.int, b.int)
proc harmful {.raises: [].} =
  # does not compile, `sort` can now raise Exception
  toSort.sort cmpE