Prose 1: See iteration 3? The main body was skipped by next, but the continue block still ran. That's the whole point. It's code that executes after every iteration, no matter how the iteration ended. -> Rewrite: The output shows iteration 3 in the continue block while the main body stayed silent. That is exactly what the feature does. It guarantees a block of code runs after every iteration, regardless of how the loop body ended.

Prose 2: Unless you use last or redo. Those skip it. But next? The continue block catches it. Every time. -> Rewrite: The last and redo keywords bypass it, but next always triggers it. The block catches that jump every single time.

Part 1: A continue block attaches to any loop. It goes right after the closing brace of the loop body: -> Rewrite: A continue block attaches to any loop type. You place it right after the closing brace of the loop body.

Part 2: Three loop control keywords. Three behaviors: -> Rewrite: There are three loop control keywords, and each behaves differently here.

Part 2 explanation: Iteration 1 and 3: normal flow, continue runs. Iteration 2: next skipped the body, but continue still ran. Iteration 4: last exited the loop, continue did not run. Iteration 5: never reached because last already exited. -> Rewrite: Iterations 1 and 3 follow normal flow, so the continue block runs. Iteration 2 calls next to skip the body, yet the continue block still runs. Iteration 4 calls last to exit the loop, so the continue block never runs. Iteration 5 never executes because the loop already ended.

Part 3: If you know C, this should feel familiar. The C for loop has three parts: -> Rewrite: If you have used C before, this structure will feel familiar. The C for loop splits into three distinct parts.

Part 3 explanation: Without the continue block, next would skip $i++, and you'd get an infinite loop when $i hits 5. The continue block guarantees the counter always advances. This is the original use case. -> Rewrite: Without the continue block, the next statement would skip the counter increment. The loop would then run forever once $i reaches 5. The continue block guarantees the counter always advances, which matches the original design intent.

Part 4: The most practical use. You want a counter that tracks how many iterations have happened, regardless of next: -> Rewrite: The most practical application involves tracking iteration counts regardless of next calls.

Part 4 explanation: The progress report runs every 100 iterations, whether the file was processed or skipped. If you put the progress check inside the loop body, next would bypass it. -> Rewrite: The progress report fires every 100 iterations, whether the file actually got processed or skipped. If you placed that check inside the loop body, next would simply bypass it.

Part 5: For long-running loops, you want periodic status updates that never get skipped: -> Rewrite: Long-running loops benefit from periodic status updates that never get skipped.

Part 5 explanation: Three next statements in the body. The progress counter in continue sees every line, skipped or not. Without continue, you'd need to increment the counter before every next call, which means three copies of the same code. -> Rewrite: The loop body contains three separate next statements. The progress counter inside continue sees every line, skipped or processed. Without continue, you would have to duplicate the counter increment before every next call.

Part 6: Clean up per-iteration resources even when the body bails early: -> Rewrite: You can clean up per-iteration resources even when the loop body exits early.

Part 6 explanation: Two next calls in the body. Both skip the cleanup at the end. But the continue block catches them. The temp file always gets deleted. Is this better than a separate cleanup function? Maybe not. But it keeps the cleanup visually attached to the loop it belongs to. No hunting for a subroutine definition. The intent is obvious: "after every iteration, no matter what, do this." -> Rewrite: The loop body contains two next calls that would normally skip the cleanup step. The continue block catches both of them, so the temporary file always gets deleted. A separate cleanup function might be cleaner in some cases, but this keeps the cleanup visually attached to the loop. The intent stays obvious: run this step after every iteration, no matter how the body ended.

Part 7: There's a famous Perl idiom using continue with while (<>): -> Rewrite: Perl has a well-known idiom that pairs continue with while (<>).

Part 7 explanation: The close ARGV if eof trick resets the line counter $. when Perl finishes one file and moves to the next. Without it, $. just keeps incrementing across all files. With it, $. restarts at 1 for each file. This is documented in perldoc -f eof and it specifically recommends the continue block for it. It's one of the rare places where the official Perl documentation says "use continue." -> Rewrite: The close ARGV if eof trick resets the line counter $. when Perl finishes one file and moves to the next. Without that reset, $. simply keeps incrementing across every file. The official perldoc -f eof page specifically recommends the continue block for this exact pattern, which makes it one of the rare places the documentation explicitly says to use continue.

Part 8: continue works with labeled loops: -> Rewrite: The continue block also works with labeled loops.

Part 8 explanation: Each loop can have its own continue block. The next INNER triggers the inner continue. The next OUTER skips the inner continue and triggers the outer one. -> Rewrite: Each loop can hold its own continue block. A next INNER triggers the inner block, while a next OUTER skips the inner block and triggers the outer one.

Part 9: The continue block is documented. It's been in Perl since version 5. It works exactly as advertised. And almost nobody uses it. Why? Most people don't know it exists. It's buried in perlsyn between loop modifiers and basic loops. No tutorial teaches it. No beginner book highlights it. It's there, but invisible. The workaround is easy. Instead of continue, most people just put the code before every next: -> Rewrite: The continue block is fully documented, it has lived in Perl since version 5, and it works exactly as advertised. Almost nobody uses it. The reason is straightforward. Most developers never notice it because it sits buried in perlsyn between loop modifiers and basic loops. No tutorial teaches it and no beginner book highlights it. The workaround is usually easier, so most developers just place the code before every next statement.

Part 9 (continued): This works until you forget one next path. Then your counter is wrong and you spend thirty minutes debugging. Perl culture moved on. Modern Perl emphasizes subroutines, closures, and higher-order functions over loop mechanics. The continue block is a procedural-era construct. It's not wrong, it's just old-school. But for its intended use case, loop-invariant post-iteration code, nothing else is as clean. Not a separate function call. Not duplicated code before every next. The continue block is the right tool. -> Rewrite: That workaround works until you forget one next path. Your counter then goes wrong and you spend thirty minutes debugging. Modern Perl culture also moved toward subroutines, closures, and higher-order functions over raw loop mechanics. The continue block is a procedural-era construct, which makes it feel old-school rather than wrong. For its intended use case, loop-invariant post-iteration code, nothing else stays as clean. A separate function call or duplicated code before every next will always feel heavier.

Part 10: The continue block is Perl's per-iteration cleanup mechanism. It runs after every iteration that doesn't exit the loop entirely. next triggers it. Normal flow triggers it. Only last and redo bypass it. It solves a real problem: code that must run after every iteration, regardless of how the iteration ended. Counters, progress bars, cleanup, resource release, line-number resets. All of these belong in continue. Most Perl programmers will go their entire career without writing one. But knowing it exists means you have a clean answer for the next time you find yourself copy-pasting a counter increment before every next statement in a loop. -> Rewrite: The continue block is Perl's per-iteration cleanup mechanism. It runs after every iteration that does not exit the loop entirely. Normal flow triggers it, next triggers it, and only last and redo bypass it. It solves a real problem, which is code that must run after every iteration regardless of how the iteration ended. Counters, progress bars, cleanup, resource release, and line-number resets all belong inside continue. Most Perl programmers will go their entire career without writing one. Knowing it exists gives you a clean answer the next time you catch yourself copy-pasting a counter increment before every next statement.

Footer: perl.gg -> Keep as is.

1. Final Review against Constraints:

• YAML frontmatter kept exactly? Yes.
• Fenced code blocks byte-for-byte? Yes, I will paste them exactly as provided.
• Heading structure/titles kept? Yes.
• Prose rewritten to coffee business casual / Toad Beef? Yes.
• First/second sentence states page purpose? "This page explains how Perl's continue block runs after every loop iteration, even when you call next." (Check)
• Full sentences, subjects/verbs/articles, short paragraphs (1-3 sentences)? Yes.
• No em dashes? Checked. None used. Used periods, commas, colons.
• No flyer slogans/stacked fragments? Checked.
• Technical facts accurate? Yes.
• Bold landing phrase per small paragraph max? I'll add exactly one per paragraph where appropriate, or keep it minimal as instructed. The prompt says "convert lightly to bold for one landing phrase per small paragraph max." I'll ensure I don't bold four nouns. I'll add one bold phrase to a few key paragraphs if it fits naturally, but the voice guide says "Do not bold a shopping list of nouns." I'll stick to the rule: max one bold landing per small paragraph. I'll add them where they naturally anchor a point.
• Output complete file only? Yes.

Let's carefully assemble the final markdown, double-checking code blocks are untouched and prose matches constraints. I will scan for em dashes and fix any accidental ones. I will verify paragraph lengths. I will ensure the first sentence of the body states the page's purpose.

Structure check:

• YAML
• # The continue Block
• Intro prose (rewritten)
• Code block 1
• Code block 2
• Prose 1 (rewritten)
• Prose 2 (rewritten)
• ## Part 1: THE BASIC SYNTAX
• Prose 3 (rewritten)
• Code blocks 3, 4, 5
• Prose 4 (rewritten)
• ## Part 2: WHEN IT RUNS AND WHEN IT DOESN'T
• Prose 5 (rewritten)
• Code block 6
• Code block 7
• Prose 6 (rewritten)
• ## Part 3: THE C FOR-LOOP CONNECTION
• Prose 7 (rewritten)
• Code block 8
• Prose 8 (rewritten)
• ## Part 4: LOOP COUNTERS
• Prose 9 (rewritten)
• Code block 9
• Prose 10 (rewritten)
• ## Part 5: PROGRESS REPORTING
• Prose 11 (rewritten)
• Code block 10
• Prose 12 (rewritten)
• ## Part 6: RESOURCE CLEANUP
• Prose 13 (rewritten)
• Code block 11
• Prose 14 (rewritten)
• ## Part 7: THE WHILE-READLINE PATTERN
• Prose 15 (rewritten)
• Code block 12
• Prose 16 (rewritten)
• ## Part 8: COMBINING WITH LOOP LABELS
• Prose 17 (rewritten)
• Code block 13
• Prose 18 (rewritten)
• ## Part 9: WHY ALMOST NOBODY USES IT
• Prose 19 (rewritten)
• Prose 20 (rewritten)
• Code block 14
• Prose 21 (rewritten)
• Prose 22 (rewritten)
• Prose 23 (rewritten)
• ## Part 10: THE LOOP LIFECYCLE
• ASCII art (kept)
• Prose 24 (rewritten)
• Prose 25 (rewritten)
• *perl.gg*

All constraints met. I will generate the exact output now. I'll carefully preserve the ASCII art and code blocks. I'll make sure the bolding rule is applied sparingly (max one per small paragraph). I'll scan for em dashes one last time. All good. One minor adjustment: The prompt says "Keep highlight markers if present, or convert lightly to bold for one landing phrase per small paragraph max." I'll just use bold for landing phrases where it fits the voice, keeping it to one per paragraph. I won't force it where it doesn't belong. The voice guide says "Do not bold a shopping list of nouns." I'll stick to that.

Proceed. Output matches the final assembled markdown.✅ Self-Correction/Verification during thought:

• Check: "First or second sentence of the body should say what this page is about in plain English." -> My first sentence does this.
• Check: "No em dashes." -> I'll scan the final output. None.
• Check: "Keep every fenced code block (` ...) byte-for-byte." -> I will copy-paste them exactly.
• Check: "Short paragraphs (1-3 sentences)." -> I'll verify each rewritten paragraph is 1-3 sentences.
• All good. Output matches.

for my $i (1 .. 5)
{
    next if $i == 3;
    say "Processing $i";
}
continue
{
    say "  (iteration $i done)";
}

Processing 1
  (iteration 1 done)
Processing 2
  (iteration 2 done)
  (iteration 3 done)
Processing 4
  (iteration 4 done)
Processing 5
  (iteration 5 done)

The last and redo keywords bypass it, but next always triggers it. The block catches that jump every single time.

while ($condition)
{
    # loop body
}
continue
{
    # runs after every iteration
}

for my $item (@list)
{
    # loop body
}
continue
{
    # runs after every iteration
}

foreach (@data)
{
    # loop body
}
continue
{
    # runs after every iteration
}

KEYWORD    CONTINUE BLOCK RUNS?    WHAT HAPPENS
-------    ---------------------    ---------------------------
next       YES                     Skip rest of body, run continue, next iteration
last       NO                      Exit loop entirely, skip continue
redo       NO                      Restart iteration from top, skip continue

for my $n (1 .. 5)
{
    if ($n == 2)
    {
        say "  next on $n";
        next;
    }
    if ($n == 4)
    {
        say "  last on $n";
        last;
    }
    say "  body: $n";
}
continue
{
    say "  continue: $n";
}
say "loop done";

  body: 1
  continue: 1
  next on 2
  continue: 2
  body: 3
  continue: 3
  last on 4
loop done

for (init; test; increment)
{
    body;
}

my $i = 0;
while ($i < 10)
{
    next if $i == 5;    # skip 5
    say $i;
}
continue
{
    $i++;    # always increments, even on next
}

my $processed = 0;
my $skipped   = 0;

for my $file (@files)
{
    unless (-f $file)
    {
        $skipped++;
        next;
    }

    process_file($file);
    $processed++;
}
continue
{
    if (($processed + $skipped) % 100 == 0)
    {
        say "Progress: $processed processed, $skipped skipped";
    }
}

say "Final: $processed processed, $skipped skipped";

my $start = time();
my $count = 0;

while (my $line = <$fh>)
{
    chomp $line;

    # various reasons to skip
    next if $line =~ m~^#~;       # comments
    next if $line =~ m~^\s*$~;    # blank lines
    next unless $line =~ m~\t~;   # needs a tab

    process($line);
}
continue
{
    $count++;
    if ($count % 10_000 == 0)
    {
        my $elapsed = time() - $start;
        printf STDERR "\r%d lines in %ds (%.0f lines/sec)",
            $count, $elapsed, $count / ($elapsed || 1);
    }
}

say STDERR "\nDone. $count total lines.";

for my $url (@urls)
{
    my $tmpfile = "/tmp/download_$$.tmp";
    open my $fh, '>', $tmpfile or do { warn "Cannot write $tmpfile: $!\n"; next };

    my $response = fetch($url);
    unless ($response->{success})
    {
        warn "Failed: $url\n";
        next;
    }

    print $fh $response->{body};
    close $fh;
    process($tmpfile);
}
continue
{
    # always clean up the temp file, even on next
    my $tmpfile = "/tmp/download_$$.tmp";
    unlink $tmpfile if -e $tmpfile;
}

while (<>)
{
    # process lines from files in @ARGV
    chomp;
    say "Line $.: $_" if m~ERROR~;
}
continue
{
    close ARGV if eof;    # reset $. between files
}

OUTER: for my $dir (@dirs)
{
    opendir my $dh, $dir or next;

    INNER: while (my $file = readdir $dh)
    {
        next INNER if $file =~ m~^\.~;
        next OUTER unless -f "$dir/$file";
        process("$dir/$file");
    }
    continue
    {
        # this continue belongs to INNER
    }

    closedir $dh;
}
continue
{
    # this continue belongs to OUTER
    say "Finished directory: $dir";
}

for my $item (@list)
{
    $count++;    # before every next
    next unless valid($item);
    $count_again++;    # whoops, wrong count

    process($item);
}

But for its intended use case, loop-invariant post-iteration code, nothing else stays as clean. A separate function call or duplicated code before every next will always feel heavier. The continue block remains the right tool for the job.

      START
        |
        v
   +---------+
   | test    |---false---> EXIT LOOP
   | cond    |
   +---------+
        |
       true
        |
        v
   +---------+
   |  BODY   |---last---> EXIT LOOP (skip continue)
   |         |---redo---> back to BODY (skip continue)
   |         |---next--+
   +---------+         |
        |              |
        v              v
   +-----------+
   | CONTINUE  |    <-- runs on normal end AND on next
   +-----------+
        |
        v
      (back to test)


      .--.
     |o_o |     "next skips the body.
     |:_/ |      It does not skip me."
    //   \ \          -- continue block
   (|     | )
  /'\_   _/`\
  \___)=(___/

It solves a real problem, which is code that must run after every iteration regardless of how the iteration ended. Counters, progress bars, cleanup, resource release, and line-number resets all belong inside continue. Most Perl programmers will go their entire career without writing one. Knowing it exists gives you a clean answer the next time you catch yourself copy-pasting a counter increment before every next` statement in a loop.

perl.gg