Result support: allow propagation of CancelledError in `catch`

[emizzle]

For when Result support will be more tightly integrated into chronos, it would be nice to have a catch that takes into account, and propagates, CancelledError, eg:

template catchAsync*(body: typed): Result[type(body), ref CatchableError] =
  ## Catch exceptions for `body` containing `await` and store them in the
  ## Result, propagating cancellations.
  ##
  ## ```
  ## let r = catchAsync: await someAsyncFuncThatMayRaise()
  ## ```
  type R = Result[type(body), ref CatchableError]

  try:
    when type(body) is void:
      body
      R.ok()
    else:
      R.ok(body)
  except CancelledError as eCancelled:
    raise eCancelled
  except CatchableError as eResultPrivate:
    R.err(eResultPrivate)

[cheatfate]

Why do you need Result here?
How you handle ref CatchableError errors? Is there any examples on this template usage?

[emizzle]

Why do you need Result here?

Without going down that rabbit hole of Results vs exceptions (that we've all been down), Results are never absolutely needed, but using Results instead of exceptions could be wanted.

How you handle ref CatchableError errors? Is there any examples on this template usage?

To provide a made up example, we could have a case of an async proc doing some IO that should propagate CancelledError and return a Result:

# ?! is an alias for Result[int, CatchableError]
proc doSomeOp(): ?!void {.async: (raises: [CancelledError]).} =
  (await doSomeIO()).catchAsync
  return ok

catchAsync will propagate cancellation and it will return a Result.err when there is an exception. In other words, catchAsync only allows CancelledError to propagate.

Another idea

There are probably better ways to do this, like controlling cancellation propagation in the pragma, eg allowing both

# implicitly raises `CancelledError`
# bubbleCancellation would default to `true`
{.async: (bubbleCancellation: true, raises: []).}

# does not implicitly raise `CancelledError`
{.async: (bubbleCancellation: false, raises: []).}

# however, this should not compile since `CancelledError` would be raised
{.async: (bubbleCancellation: true, raises: []).}

This would give the user a choice to say, eg "since I'm asyncSpawning this proc, I don't want to bubbleCancellation or else I'll Defect".

[cheatfate]

But {.async: (raises: []).} means that it will NOT "bubbleCancellation" because it will not raise CancelledError, while {.async: (raises: [CancelledError]).} means that it will "bubbleCancellation".

[emizzle]

Sorry, I kind of glazed over that detail and clearly made a mistake in my very last suggestion. Let's continue this part of discussion in #570 so as not to derail the Result topic.