add delimited continuations #1530

zerbina · 2025-04-19T19:01:36Z

Summary

Add the suspend magic operator, which creates a reified continuation (a procedure + context object) out of the remainder of a routine.

Details

suspend is the best interface I could come up with so far, but I don't particularly like it and it doesn't have to be final.

The internal primitives that the language-level interface (currently suspend) is implemented with are fork and land:

land marks a resumption point
fork saves the current local context and returns it as an object together with the reified continuation for the forked-to resumption point

Each fork must be paired with exactly one distinct land, and the latter must not be reachable from the former.

fork and land use a backend-agnostic MIR lowering and are thus automatically supported by all MIR- and CGIR-based code generators (i.e., all current backends).

To-Do

implement the fork/land lowering pass
make the .tailcall lowering a MIR pass (so that it can happen after fork/land lowering)
rename land to resume (the existing mnkResume needs to be renamed to mnkUnwind)
implement the static semantics for suspend as described in the manual
add tests for suspend
write a proper commit message

It's a bit too magic, and dedicated abstract (and concrete) syntax would be probably be better in the longer term. Nonetheless, it's possible to make due with a magic call for now.

Most of the rules in the manual are not yet enforced.

The call expression is invoked as if it were the last expression in the body, so a tail call is possible.

They are the MIR operators `suspend` will be implemented with.

It's easiest to lower `suspend` into `fork` + `land` directly in `mirgen`, which also means that the proper control flow graph is available right away.

It also acts as a test for the compiler.

saem · 2025-04-19T20:42:22Z

compiler/sem/semmagic.nim

@@ -410,6 +410,100 @@ proc semPrivateAccess(c: PContext, n: PNode): PNode =
  c.currentScope.allowPrivateAccess.add t.sym
  result = newNodeIT(nkEmpty, n.info, getSysType(c.graph, n.info, tyVoid))

+proc semSuspend(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
+  ## Analyzes a 'suspend' magic call, producing a typed AST or an error. If
+  ## the call doesn't have the right shape, analysis fall back to overload


Suggested change

## the call doesn't have the right shape, analysis fall back to overload

## the call doesn't have the right shape, analysis falls back to overload

Possible typo.

saem · 2025-04-19T20:54:45Z

compiler/sem/semmagic.nim

+
+  c.openScope()
+  # create a let section and type that. This makes sure the symbol is properly
+  # registered everywhere, and retyping is also taken care. The initializer


Suggested change

# registered everywhere, and retyping is also taken care. The initializer

# registered everywhere, and retyping is also taken care of. The initializer

Minor typo.

doc/manual.rst

saem · 2025-04-19T21:02:22Z

doc/manual.rst

+7. let `ctx` refer to the saved context (a value of type `Ctx`)
+8. let `call` refer to the third argument expression
+
+`call` is typed as if would the expression were the following:


Suggested change

`call` is typed as if would the expression were the following:

`call` is typed as if the expression were the following:

saem · 2025-04-19T21:16:32Z

doc/manual.rst

+
+If `ctx` (or a copy thereof) goes out scope without having been consumed by a
+call to the continuation, cleanup happens as if unwinding would take place
+right the `suspend` call, but without `finally`:idx: clauses being visited.


Suggested change

right the `suspend` call, but without `finally`:idx: clauses being visited.

right after the `suspend` call, but without `finally`:idx: clauses being visited.

I think that's what was meant?

saem · 2025-04-19T21:28:14Z

lib/system.nim

@@ -3070,6 +3070,12 @@ when defined(nimDebugUtils):
 proc `not`*[T: ref or ptr](a: typedesc[T], b: typeof(nil)): typedesc {.magic: "TypeTrait", noSideEffect.}
  ## Constructs a `not nil` type.

+when defined(nimskullHasSuspend):
+  proc suspend*[T](with: typedesc[T], name, call: untyped): T {.magic: "Suspend", noSideEffect.} =


As of this moment, reading the PR, reminding myself or redex vs continuation definitions (Lexi's talk), and seeing as suspend creates a reified continuation, I'm inclined to say continuation is a better name than suspend.

Beyond, continuation is largely what would follow in a continuation(...): ... call, I have a feeling that suspend is a bit too evocative of something like async/await or coroutines.

The above is my current thing, and undoubtedly as I reread this PR as it evolves, and especially the docs, I'll end up with a different suggestion(s) and preference. I would just treat this as a data point.

Here's an alternative interface I made to look less magical:

proc suspend[T; Prc: proc](with: typedesc[T], name, prc: Prc, args: tupleFromArgs(Prc)): T

where tupleFromArgs() is a "magic" that convert the argument list into a tuple type

Re: the name suspend, I think it's a good one, as when viewed from the writer's PoV, you "stop" the procedure at the specified point, and then resume it elsewhere. The fact that it creates a continuation is merely an implementation detail so you can do the resuming part.

I like the generality of tupleFromArgs, it'd be handy for template/macro writing. I do think writing suspend directly will be less pleasant. Perhaps overloading can help there, with something like a typed macro extracting the caller from a call.

I agree that having tupleFromArgs (though I'd name it differently) would be useful. It's possible to implement via a macro, but this is error prone and effectively requires using the unstable macro type API.

Here's an alternative interface I made to look less magical:

proc suspend[T; Prc: proc](with: typedesc[T], name, prc: Prc, args: tupleFromArgs(Prc)): T

As is, this won't work, for multiple reasons:

name being untyped was deliberate, it's not a procedure: the parameter accepts an untyped identifier. However, changing name to untyped in your signature also won't work

proper parameter passing cannot be emulated with a tuple. Of course, one could require the argument being an immediate tuple construction and then construct a call from it, but this a lot more "magical" - for both the compiler and user - than the current interface

using overloaded routines as the receiver (i.e. prc) is not possible

There's also another internally-facing problem: there's no call of prc in the typed AST, which means that multiple places in the compiler would need special handling for suspend (which the current interface gets around).

Finally, keep in mind that suspend is a non-overloadable magic at the moment, and with its current shape, it cannot be anything else. In other words, the signature you see in system is largely irrelevant to the compiler -- it's only there for documentation purposes.

Ultimately, I believe that dedicated abstract (and concrete) syntax would be a better fit for this feature, though I'm rather reluctant to take that route.

saem · 2025-04-19T23:27:29Z

doc/manual.rst

+Evaluation of `suspend`:idx: works as follows:
+1. the current local context is saved
+2. `local` is intialized with the tuple `(ctx, prc)`
+3. all local variables (except `local`) or sink parameters of the caller used


Suggested change

3. all local variables (except `local`) or sink parameters of the caller used

3. all local variables (except `local`) and sink parameters of the caller used

I believe this was the intention

zerbina · 2025-04-21T17:50:56Z

Hm, there's one thing I didn't consider: address stability. The address of a local doesn't stay the same across a suspend, which would mean that code such as:

proc test() =
  var a = 0
  var b = addr a
  suspend ...
  echo b[]

is going to invoked undefined behaviour upon evaluation b[], as b would point into the memory of a dead frame at that point.

The only solution to this I can think of is disallowing taking the address of a location where the address value might be live beyond a suspend call. That is:

proc test() =
  var a = 0
  block:
    var b = 0
    discard addr(b) # allowed
  discard addr(a)   # disallowed
  suspend ...
  discard addr(a) # allowed, because there's no following `suspend`

Of course, this rule won't be able to reject code such as:

proc hiddenAddr(x: var int): ptr int =
  addr x

proc test() =
  var a = 0
  var b = hiddenAddr(a)
  suspend ...
  echo b[]

Finally, implementing this rule is going to be a nuisance: either sempass2 needs to be extended with a dedicated pass (prone to mistakes and hard to maintain), or a MIR pass has to be used, which would mean that neither nim check or nimsuggest will report an error.

zerbina added 8 commits April 14, 2025 23:08

manual: first version of a specification

2e032aa

system: add the suspend magic

25747c7

It's a bit too magic, and dedicated abstract (and concrete) syntax would be probably be better in the longer term. Nonetheless, it's possible to make due with a magic call for now.

sem: implement the first version of suspend analysis

960df89

Most of the rules in the manual are not yet enforced.

tailcall_analysis: allow tail calls in suspend

07548f0

The call expression is invoked as if it were the last expression in the body, so a tail call is possible.

mir: add mnkFork and mnkLand

3d87dda

They are the MIR operators `suspend` will be implemented with.

mirgen: implement a first version of the suspend lowering

09cf602

It's easiest to lower `suspend` into `fork` + `land` directly in `mirgen`, which also means that the proper control flow graph is available right away.

document the planned lowering approach

648effc

add a small demo

f60b704

It also acts as a test for the compiler.

zerbina added enhancement New feature or request language-design Language design syntax, semantics, types, statics and dynamics. labels Apr 19, 2025

zerbina marked this pull request as draft April 19, 2025 19:02

saem reviewed Apr 19, 2025

View reviewed changes

doc/manual.rst Show resolved Hide resolved

saem reviewed Apr 19, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

add delimited continuations #1530

add delimited continuations #1530

zerbina commented Apr 19, 2025

saem Apr 19, 2025

saem Apr 19, 2025

saem Apr 19, 2025

saem Apr 19, 2025

saem Apr 19, 2025

alaviss Apr 19, 2025

saem Apr 19, 2025

zerbina Apr 20, 2025

saem Apr 19, 2025 •

edited

Loading

zerbina commented Apr 21, 2025

	## the call doesn't have the right shape, analysis fall back to overload
	## the call doesn't have the right shape, analysis falls back to overload

	# registered everywhere, and retyping is also taken care. The initializer
	# registered everywhere, and retyping is also taken care of. The initializer

	`call` is typed as if would the expression were the following:
	`call` is typed as if the expression were the following:

	right the `suspend` call, but without `finally`:idx: clauses being visited.
	right after the `suspend` call, but without `finally`:idx: clauses being visited.

	3. all local variables (except `local`) or sink parameters of the caller used
	3. all local variables (except `local`) and sink parameters of the caller used

add delimited continuations #1530

Are you sure you want to change the base?

add delimited continuations #1530

Conversation

zerbina commented Apr 19, 2025

Summary

Details

To-Do

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

saem Apr 19, 2025 • edited Loading

Choose a reason for hiding this comment

zerbina commented Apr 21, 2025

saem Apr 19, 2025 •

edited

Loading