Continue
Skips to the enclosing loop's next iteration.
Purpose
Abandons the rest of the current pass and starts the next one. The loop keeps running; only this iteration's remaining work is skipped.
When to use it
- This item is not relevant — skip it and move to the next.
- A precondition for this pass failed, but the loop should keep going.
- Filtering: process only items that match, skip the rest.
When not to use it
- To end the loop — use Break.
- To end the flow — use Return or Stop.
- Outside a loop — Continue is meaningful only inside a loop region.
Requirements
Continue must sit inside a loop region. It belongs to the innermost enclosing loop, resolved at compile time.
How it runs
Continue carries no user-wired outgoing edge. The compiler rewires it back to the loop's start, where the next iteration's condition check happens.
Skipping the body does not skip the iteration. A Count loop with max 10 that continues on every pass still performs ten passes and then exits. Continue saves the body work, not the iteration budget.
Settings
| Setting | Type | Range | Notes |
|---|---|---|---|
| Label | string | ≤ 120 chars | Optional display label only; no runtime effect |
Continue has no functional settings — its behaviour is entirely positional.
Ports
| Port | Notes |
|---|---|
| Success | Present on the node, but not user-wired — the compiler owns it |
| Fatal | Configuration fault. Never followed |
Continue has no required ports. Wire an edge into it; do not wire one out.
Basic example
Skip an item that does not qualify:
- If → False → Continue
Realistic example — filtering a list
Note how Continue and Break do different jobs in the same loop: Continue skips this item, Break stops because there are no more items.
Advanced example — guard clauses
Continue lets you write loop bodies as a series of early exits rather than deep nesting:
Each guard is a flat check with its own Continue, instead of three levels of nested Ifs. This is markedly easier to read and to extend.
Best practices
- Use Continue for guard clauses. Flat guards beat nested conditionals.
- Count what you actually processed with a separate variable — iterations and processed items are different numbers.
- Label the Continue with the reason it skipped.
- Remember iterations still count. Size Max iterations for the items you will examine, not the ones you will process.
- Pair with Break — Continue for "skip this", Break for "stop entirely".
Performance notes
- Continue itself is free, and it saves the remaining body work for that pass.
- It does not save an iteration. In a loop where most passes continue early, you still pay the loop's per-iteration overhead and the guard checks.
- If almost every pass is skipped, the filter is in the wrong place — filter before the loop where possible.
Memory notes
- No allocation. Skipped passes still record results for the nodes that did run, so
nodeResultsgrows with iterations regardless.
Common mistakes
| Mistake | What happens | Fix |
|---|---|---|
| Expecting Continue to end the loop | The loop carries on | Use Break |
| Expecting skipped passes not to count | They do count | Size Max iterations accordingly |
| Wiring an edge out of Continue | Not how it works | Wire only into it |
| Continue in the wrong nested loop | Applies to the innermost | Check the region |
| Counting iterations as processed items | Wrong totals | Use a separate counter |
Troubleshooting
The loop exits earlier than expected. Continued passes still consume the iteration budget. Raise Max iterations.
Continue behaves like Break. Check that it is inside the loop region you think it is.
Nothing is ever processed. The guard condition is inverted — verify which port leads to Continue.
FAQ
Does Continue reset the loop counter? No. It moves to the next iteration normally.
Does a continued pass count toward Max iterations? Yes.
Can I use Continue outside a loop? No.
Does Continue skip the Loop End aggregation for that pass? The pass produced no body result to aggregate, so nothing is collected for it.
Related nodes
- Loop — the region Continue belongs to
- Break — stop the loop entirely
- If — the guard that decides to skip
- Variable — count processed items separately