Rename `State::Fn` to `State::Next`

33 files changed, 411 insertions, 426 deletions

diff --git a/src/construct/attention.rs b/src/construct/attention.rs
index 5a98a89..ff33f97 100644
--- a/src/construct/attention.rs
+++ b/src/construct/attention.rs
@@ -136,7 +136,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'*' | b'_') if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker => {
             tokenizer.consume();
-            State::Fn(StateName::AttentionInside)
+            State::Next(StateName::AttentionInside)
         }
         _ => {
             tokenizer.exit(Token::AttentionSequence);
diff --git a/src/construct/autolink.rs b/src/construct/autolink.rs
index 15bfac1..f1b92d9 100644
--- a/src/construct/autolink.rs
+++ b/src/construct/autolink.rs
@@ -121,7 +121,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.consume();
             tokenizer.exit(Token::AutolinkMarker);
             tokenizer.enter(Token::AutolinkProtocol);
-            State::Fn(StateName::AutolinkOpen)
+            State::Next(StateName::AutolinkOpen)
         }
         _ => State::Nok,
     }
@@ -140,7 +140,7 @@ pub fn open(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphabetic.
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::AutolinkSchemeOrEmailAtext)
+            State::Next(StateName::AutolinkSchemeOrEmailAtext)
         }
         _ => email_atext(tokenizer),
     }
@@ -179,7 +179,7 @@ pub fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer) -> State {
         Some(b':') => {
             tokenizer.consume();
             tokenizer.tokenize_state.size = 0;
-            State::Fn(StateName::AutolinkUrlInside)
+            State::Next(StateName::AutolinkUrlInside)
         }
         // ASCII alphanumeric and `+`, `-`, and `.`.
         Some(b'+' | b'-' | b'.' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z')
@@ -187,7 +187,7 @@ pub fn scheme_inside_or_email_atext(tokenizer: &mut Tokenizer) -> State {
         {
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            State::Fn(StateName::AutolinkSchemeInsideOrEmailAtext)
+            State::Next(StateName::AutolinkSchemeInsideOrEmailAtext)
         }
         _ => {
             tokenizer.tokenize_state.size = 0;
@@ -212,7 +212,7 @@ pub fn url_inside(tokenizer: &mut Tokenizer) -> State {
         None | Some(b'\0'..=0x1F | b' ' | b'<' | 0x7F) => State::Nok,
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::AutolinkUrlInside)
+            State::Next(StateName::AutolinkUrlInside)
         }
     }
 }
@@ -227,7 +227,7 @@ pub fn email_atext(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'@') => {
             tokenizer.consume();
-            State::Fn(StateName::AutolinkEmailAtSignOrDot)
+            State::Next(StateName::AutolinkEmailAtSignOrDot)
         }
         // ASCII atext.
         //
@@ -250,7 +250,7 @@ pub fn email_atext(tokenizer: &mut Tokenizer) -> State {
             b'#'..=b'\'' | b'*' | b'+' | b'-'..=b'9' | b'=' | b'?' | b'A'..=b'Z' | b'^'..=b'~',
         ) => {
             tokenizer.consume();
-            State::Fn(StateName::AutolinkEmailAtext)
+            State::Next(StateName::AutolinkEmailAtext)
         }
         _ => State::Nok,
     }
@@ -281,7 +281,7 @@ pub fn email_label(tokenizer: &mut Tokenizer) -> State {
         Some(b'.') => {
             tokenizer.tokenize_state.size = 0;
             tokenizer.consume();
-            State::Fn(StateName::AutolinkEmailAtSignOrDot)
+            State::Next(StateName::AutolinkEmailAtSignOrDot)
         }
         Some(b'>') => {
             tokenizer.tokenize_state.size = 0;
@@ -310,14 +310,14 @@ pub fn email_value(tokenizer: &mut Tokenizer) -> State {
         Some(b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z')
             if tokenizer.tokenize_state.size < AUTOLINK_DOMAIN_SIZE_MAX =>
         {
-            let state_name = if matches!(tokenizer.current, Some(b'-')) {
+            let name = if matches!(tokenizer.current, Some(b'-')) {
                 StateName::AutolinkEmailValue
             } else {
                 StateName::AutolinkEmailLabel
             };
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            State::Fn(state_name)
+            State::Next(name)
         }
         _ => {
             tokenizer.tokenize_state.size = 0;
diff --git a/src/construct/blank_line.rs b/src/construct/blank_line.rs
index 22dfdc0..d7d4817 100644
--- a/src/construct/blank_line.rs
+++ b/src/construct/blank_line.rs
@@ -46,11 +46,11 @@ use crate::tokenizer::{State, StateName, Tokenizer};
 ///     ^
 /// ```
 pub fn start(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab(tokenizer);
+    let name = space_or_tab(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::BlankLineAfter),
-        State::Fn(StateName::BlankLineAfter),
+        name,
+        State::Next(StateName::BlankLineAfter),
+        State::Next(StateName::BlankLineAfter),
     )
 }
 
diff --git a/src/construct/block_quote.rs b/src/construct/block_quote.rs
index cec3dce..0e02be9 100644
--- a/src/construct/block_quote.rs
+++ b/src/construct/block_quote.rs
@@ -46,7 +46,7 @@ use crate::tokenizer::{State, StateName, Tokenizer};
 /// ```
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.block_quote {
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -55,11 +55,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
                 usize::MAX
             },
         );
-        tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::BlockQuoteBefore),
-            State::Nok,
-        )
+        tokenizer.attempt(name, State::Next(StateName::BlockQuoteBefore), State::Nok)
     } else {
         State::Nok
     }
@@ -89,7 +85,7 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
 ///     ^
 /// ```
 pub fn cont_start(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_min_max(
+    let name = space_or_tab_min_max(
         tokenizer,
         0,
         if tokenizer.parse_state.constructs.code_indented {
@@ -99,8 +95,8 @@ pub fn cont_start(tokenizer: &mut Tokenizer) -> State {
         },
     );
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::BlockQuoteContBefore),
+        name,
+        State::Next(StateName::BlockQuoteContBefore),
         State::Nok,
     )
 }
@@ -119,7 +115,7 @@ pub fn cont_before(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::BlockQuoteMarker);
             tokenizer.consume();
             tokenizer.exit(Token::BlockQuoteMarker);
-            State::Fn(StateName::BlockQuoteContAfter)
+            State::Next(StateName::BlockQuoteContAfter)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/character_escape.rs b/src/construct/character_escape.rs
index de09f17..52b2873 100644
--- a/src/construct/character_escape.rs
+++ b/src/construct/character_escape.rs
@@ -49,7 +49,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::CharacterEscapeMarker);
             tokenizer.consume();
             tokenizer.exit(Token::CharacterEscapeMarker);
-            State::Fn(StateName::CharacterEscapeInside)
+            State::Next(StateName::CharacterEscapeInside)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/character_reference.rs b/src/construct/character_reference.rs
index ba05fab..5a0e15c 100644
--- a/src/construct/character_reference.rs
+++ b/src/construct/character_reference.rs
@@ -86,7 +86,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::CharacterReferenceMarker);
             tokenizer.consume();
             tokenizer.exit(Token::CharacterReferenceMarker);
-            State::Fn(StateName::CharacterReferenceOpen)
+            State::Next(StateName::CharacterReferenceOpen)
         }
         _ => State::Nok,
     }
@@ -109,7 +109,7 @@ pub fn open(tokenizer: &mut Tokenizer) -> State {
         tokenizer.enter(Token::CharacterReferenceMarkerNumeric);
         tokenizer.consume();
         tokenizer.exit(Token::CharacterReferenceMarkerNumeric);
-        State::Fn(StateName::CharacterReferenceNumeric)
+        State::Next(StateName::CharacterReferenceNumeric)
     } else {
         tokenizer.tokenize_state.marker = b'&';
         tokenizer.enter(Token::CharacterReferenceValue);
@@ -134,7 +134,7 @@ pub fn numeric(tokenizer: &mut Tokenizer) -> State {
         tokenizer.exit(Token::CharacterReferenceMarkerHexadecimal);
         tokenizer.enter(Token::CharacterReferenceValue);
         tokenizer.tokenize_state.marker = b'x';
-        State::Fn(StateName::CharacterReferenceValue)
+        State::Next(StateName::CharacterReferenceValue)
     } else {
         tokenizer.enter(Token::CharacterReferenceValue);
         tokenizer.tokenize_state.marker = b'#';
@@ -202,7 +202,7 @@ pub fn value(tokenizer: &mut Tokenizer) -> State {
         if tokenizer.tokenize_state.size < max && test(&byte) {
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            return State::Fn(StateName::CharacterReferenceValue);
+            return State::Next(StateName::CharacterReferenceValue);
         }
     }
 
diff --git a/src/construct/code_fenced.rs b/src/construct/code_fenced.rs
index 91fd8e4..17c7566 100644
--- a/src/construct/code_fenced.rs
+++ b/src/construct/code_fenced.rs
@@ -119,7 +119,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.code_fenced {
         tokenizer.enter(Token::CodeFenced);
         tokenizer.enter(Token::CodeFencedFence);
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -129,8 +129,8 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             },
         );
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::CodeFencedBeforeSequenceOpen),
+            name,
+            State::Next(StateName::CodeFencedBeforeSequenceOpen),
             State::Nok,
         )
     } else {
@@ -183,15 +183,15 @@ pub fn sequence_open(tokenizer: &mut Tokenizer) -> State {
         Some(b'`' | b'~') if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker => {
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            State::Fn(StateName::CodeFencedSequenceOpen)
+            State::Next(StateName::CodeFencedSequenceOpen)
         }
         _ if tokenizer.tokenize_state.size >= CODE_FENCED_SEQUENCE_SIZE_MIN => {
             tokenizer.exit(Token::CodeFencedFenceSequence);
-            let state_name = space_or_tab(tokenizer);
+            let name = space_or_tab(tokenizer);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::CodeFencedInfoBefore),
-                State::Fn(StateName::CodeFencedInfoBefore),
+                name,
+                State::Next(StateName::CodeFencedInfoBefore),
+                State::Next(StateName::CodeFencedInfoBefore),
             )
         }
         _ => {
@@ -248,11 +248,11 @@ pub fn info(tokenizer: &mut Tokenizer) -> State {
         Some(b'\t' | b' ') => {
             tokenizer.exit(Token::Data);
             tokenizer.exit(Token::CodeFencedFenceInfo);
-            let state_name = space_or_tab(tokenizer);
+            let name = space_or_tab(tokenizer);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::CodeFencedMetaBefore),
-                State::Fn(StateName::CodeFencedMetaBefore),
+                name,
+                State::Next(StateName::CodeFencedMetaBefore),
+                State::Next(StateName::CodeFencedMetaBefore),
             )
         }
         Some(b'`') if tokenizer.tokenize_state.marker == b'`' => {
@@ -264,7 +264,7 @@ pub fn info(tokenizer: &mut Tokenizer) -> State {
         }
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::CodeFencedInfo)
+            State::Next(StateName::CodeFencedInfo)
         }
     }
 }
@@ -320,7 +320,7 @@ pub fn meta(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::CodeFencedMeta)
+            State::Next(StateName::CodeFencedMeta)
         }
     }
 }
@@ -337,8 +337,8 @@ pub fn meta(tokenizer: &mut Tokenizer) -> State {
 pub fn at_break(tokenizer: &mut Tokenizer) -> State {
     tokenizer.check(
         StateName::NonLazyContinuationStart,
-        State::Fn(StateName::CodeFencedAtNonLazyBreak),
-        State::Fn(StateName::CodeFencedAfter),
+        State::Next(StateName::CodeFencedAtNonLazyBreak),
+        State::Next(StateName::CodeFencedAfter),
     )
 }
 
@@ -354,8 +354,8 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
 pub fn at_non_lazy_break(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::CodeFencedCloseBefore,
-        State::Fn(StateName::CodeFencedAfter),
-        State::Fn(StateName::CodeFencedContentBefore),
+        State::Next(StateName::CodeFencedAfter),
+        State::Next(StateName::CodeFencedContentBefore),
     )
 }
 
@@ -373,7 +373,7 @@ pub fn close_before(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::CodeFencedCloseStart)
+            State::Next(StateName::CodeFencedCloseStart)
         }
         _ => unreachable!("expected eol"),
     }
@@ -389,7 +389,7 @@ pub fn close_before(tokenizer: &mut Tokenizer) -> State {
 /// ```
 pub fn close_start(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::CodeFencedFence);
-    let state_name = space_or_tab_min_max(
+    let name = space_or_tab_min_max(
         tokenizer,
         0,
         if tokenizer.parse_state.constructs.code_indented {
@@ -399,8 +399,8 @@ pub fn close_start(tokenizer: &mut Tokenizer) -> State {
         },
     );
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::CodeFencedBeforeSequenceClose),
+        name,
+        State::Next(StateName::CodeFencedBeforeSequenceClose),
         State::Nok,
     )
 }
@@ -436,18 +436,18 @@ pub fn sequence_close(tokenizer: &mut Tokenizer) -> State {
         Some(b'`' | b'~') if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker => {
             tokenizer.tokenize_state.size_other += 1;
             tokenizer.consume();
-            State::Fn(StateName::CodeFencedSequenceClose)
+            State::Next(StateName::CodeFencedSequenceClose)
         }
         _ if tokenizer.tokenize_state.size_other >= CODE_FENCED_SEQUENCE_SIZE_MIN
             && tokenizer.tokenize_state.size_other >= tokenizer.tokenize_state.size =>
         {
             tokenizer.tokenize_state.size_other = 0;
             tokenizer.exit(Token::CodeFencedFenceSequence);
-            let state_name = space_or_tab(tokenizer);
+            let name = space_or_tab(tokenizer);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::CodeFencedAfterSequenceClose),
-                State::Fn(StateName::CodeFencedAfterSequenceClose),
+                name,
+                State::Next(StateName::CodeFencedAfterSequenceClose),
+                State::Next(StateName::CodeFencedAfterSequenceClose),
             )
         }
         _ => {
@@ -487,7 +487,7 @@ pub fn content_before(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::LineEnding);
     tokenizer.consume();
     tokenizer.exit(Token::LineEnding);
-    State::Fn(StateName::CodeFencedContentStart)
+    State::Next(StateName::CodeFencedContentStart)
 }
 /// Before code content, definitely not before a closing fence.
 ///
@@ -498,10 +498,10 @@ pub fn content_before(tokenizer: &mut Tokenizer) -> State {
 ///   | ~~~
 /// ```
 pub fn content_start(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_min_max(tokenizer, 0, tokenizer.tokenize_state.prefix);
+    let name = space_or_tab_min_max(tokenizer, 0, tokenizer.tokenize_state.prefix);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::CodeFencedBeforeContentChunk),
+        name,
+        State::Next(StateName::CodeFencedBeforeContentChunk),
         State::Nok,
     )
 }
@@ -540,7 +540,7 @@ pub fn content_chunk(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::CodeFencedContentChunk)
+            State::Next(StateName::CodeFencedContentChunk)
         }
     }
 }
diff --git a/src/construct/code_indented.rs b/src/construct/code_indented.rs
index 0906e5f..de7683d 100644
--- a/src/construct/code_indented.rs
+++ b/src/construct/code_indented.rs
@@ -64,10 +64,10 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
     // Do not interrupt paragraphs.
     if !tokenizer.interrupt && tokenizer.parse_state.constructs.code_indented {
         tokenizer.enter(Token::CodeIndented);
-        let state_name = space_or_tab_min_max(tokenizer, TAB_SIZE, TAB_SIZE);
+        let name = space_or_tab_min_max(tokenizer, TAB_SIZE, TAB_SIZE);
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::CodeIndentedAtBreak),
+            name,
+            State::Next(StateName::CodeIndentedAtBreak),
             State::Nok,
         )
     } else {
@@ -86,8 +86,8 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
         None => after(tokenizer),
         Some(b'\n') => tokenizer.attempt(
             StateName::CodeIndentedFurtherStart,
-            State::Fn(StateName::CodeIndentedAtBreak),
-            State::Fn(StateName::CodeIndentedAfter),
+            State::Next(StateName::CodeIndentedAtBreak),
+            State::Next(StateName::CodeIndentedAfter),
         ),
         _ => {
             tokenizer.enter(Token::CodeFlowChunk);
@@ -110,7 +110,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::CodeIndentedInside)
+            State::Next(StateName::CodeIndentedInside)
         }
     }
 }
@@ -141,14 +141,14 @@ pub fn further_start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::CodeIndentedFurtherStart)
+            State::Next(StateName::CodeIndentedFurtherStart)
         }
         _ if !tokenizer.lazy => {
-            let state_name = space_or_tab_min_max(tokenizer, TAB_SIZE, TAB_SIZE);
+            let name = space_or_tab_min_max(tokenizer, TAB_SIZE, TAB_SIZE);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::CodeIndentedFurtherEnd),
-                State::Fn(StateName::CodeIndentedFurtherBegin),
+                name,
+                State::Next(StateName::CodeIndentedFurtherEnd),
+                State::Next(StateName::CodeIndentedFurtherBegin),
             )
         }
         _ => State::Nok,
@@ -174,11 +174,11 @@ pub fn further_end(_tokenizer: &mut Tokenizer) -> State {
 ///     ^
 /// ```
 pub fn further_begin(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab(tokenizer);
+    let name = space_or_tab(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::CodeIndentedFurtherAfter),
-        State::Fn(StateName::CodeIndentedFurtherAfter),
+        name,
+        State::Next(StateName::CodeIndentedFurtherAfter),
+        State::Next(StateName::CodeIndentedFurtherAfter),
     )
 }
 
diff --git a/src/construct/code_text.rs b/src/construct/code_text.rs
index 5bdefbb..729abe5 100644
--- a/src/construct/code_text.rs
+++ b/src/construct/code_text.rs
@@ -121,7 +121,7 @@ pub fn sequence_open(tokenizer: &mut Tokenizer) -> State {
     if let Some(b'`') = tokenizer.current {
         tokenizer.tokenize_state.size += 1;
         tokenizer.consume();
-        State::Fn(StateName::CodeTextSequenceOpen)
+        State::Next(StateName::CodeTextSequenceOpen)
     } else {
         tokenizer.exit(Token::CodeTextSequence);
         between(tokenizer)
@@ -144,7 +144,7 @@ pub fn between(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::CodeTextBetween)
+            State::Next(StateName::CodeTextBetween)
         }
         Some(b'`') => {
             tokenizer.enter(Token::CodeTextSequence);
@@ -171,7 +171,7 @@ pub fn data(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::CodeTextData)
+            State::Next(StateName::CodeTextData)
         }
     }
 }
@@ -187,7 +187,7 @@ pub fn sequence_close(tokenizer: &mut Tokenizer) -> State {
         Some(b'`') => {
             tokenizer.tokenize_state.size_other += 1;
             tokenizer.consume();
-            State::Fn(StateName::CodeTextSequenceClose)
+            State::Next(StateName::CodeTextSequenceClose)
         }
         _ => {
             if tokenizer.tokenize_state.size == tokenizer.tokenize_state.size_other {
diff --git a/src/construct/definition.rs b/src/construct/definition.rs
index 350992b..62d0f3b 100644
--- a/src/construct/definition.rs
+++ b/src/construct/definition.rs
@@ -119,11 +119,11 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
     if possible && tokenizer.parse_state.constructs.definition {
         tokenizer.enter(Token::Definition);
         // Note: arbitrary whitespace allowed even if code (indented) is on.
-        let state_name = space_or_tab(tokenizer);
+        let name = space_or_tab(tokenizer);
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::DefinitionBefore),
-            State::Fn(StateName::DefinitionBefore),
+            name,
+            State::Next(StateName::DefinitionBefore),
+            State::Next(StateName::DefinitionBefore),
         )
     } else {
         State::Nok
@@ -144,7 +144,7 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
             tokenizer.tokenize_state.token_3 = Token::DefinitionLabelString;
             tokenizer.attempt(
                 StateName::LabelStart,
-                State::Fn(StateName::DefinitionLabelAfter),
+                State::Next(StateName::DefinitionLabelAfter),
                 State::Nok,
             )
         }
@@ -168,7 +168,7 @@ pub fn label_after(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::DefinitionMarker);
             tokenizer.consume();
             tokenizer.exit(Token::DefinitionMarker);
-            State::Fn(StateName::DefinitionMarkerAfter)
+            State::Next(StateName::DefinitionMarkerAfter)
         }
         _ => State::Nok,
     }
@@ -176,11 +176,11 @@ pub fn label_after(tokenizer: &mut Tokenizer) -> State {
 
 /// To do.
 pub fn marker_after(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_eol(tokenizer);
+    let name = space_or_tab_eol(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::DefinitionDestinationBefore),
-        State::Fn(StateName::DefinitionDestinationBefore),
+        name,
+        State::Next(StateName::DefinitionDestinationBefore),
+        State::Next(StateName::DefinitionDestinationBefore),
     )
 }
 
@@ -199,8 +199,8 @@ pub fn destination_before(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.size_other = usize::MAX;
     tokenizer.attempt(
         StateName::DestinationStart,
-        State::Fn(StateName::DefinitionDestinationAfter),
-        State::Fn(StateName::DefinitionDestinationMissing),
+        State::Next(StateName::DefinitionDestinationAfter),
+        State::Next(StateName::DefinitionDestinationMissing),
     )
 }
 
@@ -219,8 +219,8 @@ pub fn destination_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.size_other = 0;
     tokenizer.attempt(
         StateName::DefinitionTitleBefore,
-        State::Fn(StateName::DefinitionAfter),
-        State::Fn(StateName::DefinitionAfter),
+        State::Next(StateName::DefinitionAfter),
+        State::Next(StateName::DefinitionAfter),
     )
 }
 
@@ -244,11 +244,11 @@ pub fn destination_missing(tokenizer: &mut Tokenizer) -> State {
 ///               ^
 /// ```
 pub fn after(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab(tokenizer);
+    let name = space_or_tab(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::DefinitionAfterWhitespace),
-        State::Fn(StateName::DefinitionAfterWhitespace),
+        name,
+        State::Next(StateName::DefinitionAfterWhitespace),
+        State::Next(StateName::DefinitionAfterWhitespace),
     )
 }
 
@@ -281,10 +281,10 @@ pub fn after_whitespace(tokenizer: &mut Tokenizer) -> State {
 ///           ^
 /// ```
 pub fn title_before(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_eol(tokenizer);
+    let name = space_or_tab_eol(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::DefinitionTitleBeforeMarker),
+        name,
+        State::Next(StateName::DefinitionTitleBeforeMarker),
         State::Nok,
     )
 }
@@ -302,7 +302,7 @@ pub fn title_before_marker(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.token_3 = Token::DefinitionTitleString;
     tokenizer.attempt(
         StateName::TitleStart,
-        State::Fn(StateName::DefinitionTitleAfter),
+        State::Next(StateName::DefinitionTitleAfter),
         State::Nok,
     )
 }
@@ -317,11 +317,11 @@ pub fn title_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.token_1 = Token::Data;
     tokenizer.tokenize_state.token_2 = Token::Data;
     tokenizer.tokenize_state.token_3 = Token::Data;
-    let state_name = space_or_tab(tokenizer);
+    let name = space_or_tab(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::DefinitionTitleAfterOptionalWhitespace),
-        State::Fn(StateName::DefinitionTitleAfterOptionalWhitespace),
+        name,
+        State::Next(StateName::DefinitionTitleAfterOptionalWhitespace),
+        State::Next(StateName::DefinitionTitleAfterOptionalWhitespace),
     )
 }
 
diff --git a/src/construct/hard_break_escape.rs b/src/construct/hard_break_escape.rs
index 47b7e94..fc2cbdf 100644
--- a/src/construct/hard_break_escape.rs
+++ b/src/construct/hard_break_escape.rs
@@ -54,7 +54,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         Some(b'\\') if tokenizer.parse_state.constructs.hard_break_escape => {
             tokenizer.enter(Token::HardBreakEscape);
             tokenizer.consume();
-            State::Fn(StateName::HardBreakEscapeAfter)
+            State::Next(StateName::HardBreakEscapeAfter)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/heading_atx.rs b/src/construct/heading_atx.rs
index e5bc3bd..41fad49 100644
--- a/src/construct/heading_atx.rs
+++ b/src/construct/heading_atx.rs
@@ -68,7 +68,7 @@ use crate::tokenizer::{ContentType, Event, EventType, State, StateName, Tokenize
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.heading_atx {
         tokenizer.enter(Token::HeadingAtx);
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -77,11 +77,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
                 usize::MAX
             },
         );
-        tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::HeadingAtxBefore),
-            State::Nok,
-        )
+        tokenizer.attempt(name, State::Next(StateName::HeadingAtxBefore), State::Nok)
     } else {
         State::Nok
     }
@@ -118,17 +114,13 @@ pub fn sequence_open(tokenizer: &mut Tokenizer) -> State {
         Some(b'#') if tokenizer.tokenize_state.size < HEADING_ATX_OPENING_FENCE_SIZE_MAX => {
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            State::Fn(StateName::HeadingAtxSequenceOpen)
+            State::Next(StateName::HeadingAtxSequenceOpen)
         }
         _ if tokenizer.tokenize_state.size > 0 => {
             tokenizer.tokenize_state.size = 0;
             tokenizer.exit(Token::HeadingAtxSequence);
-            let state_name = space_or_tab(tokenizer);
-            tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::HeadingAtxAtBreak),
-                State::Nok,
-            )
+            let name = space_or_tab(tokenizer);
+            tokenizer.attempt(name, State::Next(StateName::HeadingAtxAtBreak), State::Nok)
         }
         _ => {
             tokenizer.tokenize_state.size = 0;
@@ -153,12 +145,8 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
             State::Ok
         }
         Some(b'\t' | b' ') => {
-            let state_name = space_or_tab(tokenizer);
-            tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::HeadingAtxAtBreak),
-                State::Nok,
-            )
+            let name = space_or_tab(tokenizer);
+            tokenizer.attempt(name, State::Next(StateName::HeadingAtxAtBreak), State::Nok)
         }
         Some(b'#') => {
             tokenizer.enter(Token::HeadingAtxSequence);
@@ -182,7 +170,7 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
 pub fn sequence_further(tokenizer: &mut Tokenizer) -> State {
     if let Some(b'#') = tokenizer.current {
         tokenizer.consume();
-        State::Fn(StateName::HeadingAtxSequenceFurther)
+        State::Next(StateName::HeadingAtxSequenceFurther)
     } else {
         tokenizer.exit(Token::HeadingAtxSequence);
         at_break(tokenizer)
@@ -204,7 +192,7 @@ pub fn data(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HeadingAtxData)
+            State::Next(StateName::HeadingAtxData)
         }
     }
 }
diff --git a/src/construct/heading_setext.rs b/src/construct/heading_setext.rs
index a8c707a..4541a87 100644
--- a/src/construct/heading_setext.rs
+++ b/src/construct/heading_setext.rs
@@ -83,7 +83,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             .token_type
                 == Token::Paragraph)
     {
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -94,8 +94,8 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         );
 
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::HeadingSetextBefore),
+            name,
+            State::Next(StateName::HeadingSetextBefore),
             State::Nok,
         )
     } else {
@@ -132,16 +132,16 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'-' | b'=') if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker => {
             tokenizer.consume();
-            State::Fn(StateName::HeadingSetextInside)
+            State::Next(StateName::HeadingSetextInside)
         }
         _ => {
             tokenizer.tokenize_state.marker = 0;
             tokenizer.exit(Token::HeadingSetextUnderline);
-            let state_name = space_or_tab(tokenizer);
+            let name = space_or_tab(tokenizer);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::HeadingSetextAfter),
-                State::Fn(StateName::HeadingSetextAfter),
+                name,
+                State::Next(StateName::HeadingSetextAfter),
+                State::Next(StateName::HeadingSetextAfter),
             )
         }
     }
diff --git a/src/construct/html_flow.rs b/src/construct/html_flow.rs
index 128fd2e..298bcaf 100644
--- a/src/construct/html_flow.rs
+++ b/src/construct/html_flow.rs
@@ -132,7 +132,7 @@ const COMPLETE: u8 = 7;
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.html_flow {
         tokenizer.enter(Token::HtmlFlow);
-        let state_name = space_or_tab_with_options(
+        let name = space_or_tab_with_options(
             tokenizer,
             SpaceOrTabOptions {
                 kind: Token::HtmlFlowData,
@@ -147,7 +147,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             },
         );
 
-        tokenizer.attempt(state_name, State::Fn(StateName::HtmlFlowBefore), State::Nok)
+        tokenizer.attempt(name, State::Next(StateName::HtmlFlowBefore), State::Nok)
     } else {
         State::Nok
     }
@@ -163,7 +163,7 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
     if Some(b'<') == tokenizer.current {
         tokenizer.enter(Token::HtmlFlowData);
         tokenizer.consume();
-        State::Fn(StateName::HtmlFlowOpen)
+        State::Next(StateName::HtmlFlowOpen)
     } else {
         State::Nok
     }
@@ -183,13 +183,13 @@ pub fn open(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'!') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowDeclarationOpen)
+            State::Next(StateName::HtmlFlowDeclarationOpen)
         }
         Some(b'/') => {
             tokenizer.consume();
             tokenizer.tokenize_state.seen = true;
             tokenizer.tokenize_state.start = tokenizer.point.index;
-            State::Fn(StateName::HtmlFlowTagCloseStart)
+            State::Next(StateName::HtmlFlowTagCloseStart)
         }
         Some(b'?') => {
             tokenizer.tokenize_state.marker = INSTRUCTION;
@@ -198,7 +198,7 @@ pub fn open(tokenizer: &mut Tokenizer) -> State {
             tokenizer.concrete = true;
             // While we’re in an instruction instead of a declaration, we’re on a `?`
             // right now, so we do need to search for `>`, similar to declarations.
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         // ASCII alphabetical.
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
@@ -224,19 +224,19 @@ pub fn declaration_open(tokenizer: &mut Tokenizer) -> State {
         Some(b'-') => {
             tokenizer.consume();
             tokenizer.tokenize_state.marker = COMMENT;
-            State::Fn(StateName::HtmlFlowCommentOpenInside)
+            State::Next(StateName::HtmlFlowCommentOpenInside)
         }
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
             tokenizer.tokenize_state.marker = DECLARATION;
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         Some(b'[') => {
             tokenizer.consume();
             tokenizer.tokenize_state.marker = CDATA;
-            State::Fn(StateName::HtmlFlowCdataOpenInside)
+            State::Next(StateName::HtmlFlowCdataOpenInside)
         }
         _ => State::Nok,
     }
@@ -253,7 +253,7 @@ pub fn comment_open_inside(tokenizer: &mut Tokenizer) -> State {
         tokenizer.consume();
         // Do not form containers.
         tokenizer.concrete = true;
-        State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+        State::Next(StateName::HtmlFlowContinuationDeclarationInside)
     } else {
         tokenizer.tokenize_state.marker = 0;
         State::Nok
@@ -275,9 +275,9 @@ pub fn cdata_open_inside(tokenizer: &mut Tokenizer) -> State {
             tokenizer.tokenize_state.size = 0;
             // Do not form containers.
             tokenizer.concrete = true;
-            State::Fn(StateName::HtmlFlowContinuation)
+            State::Next(StateName::HtmlFlowContinuation)
         } else {
-            State::Fn(StateName::HtmlFlowCdataOpenInside)
+            State::Next(StateName::HtmlFlowCdataOpenInside)
         }
     } else {
         tokenizer.tokenize_state.marker = 0;
@@ -295,7 +295,7 @@ pub fn cdata_open_inside(tokenizer: &mut Tokenizer) -> State {
 pub fn tag_close_start(tokenizer: &mut Tokenizer) -> State {
     if let Some(b'A'..=b'Z' | b'a'..=b'z') = tokenizer.current {
         tokenizer.consume();
-        State::Fn(StateName::HtmlFlowTagName)
+        State::Next(StateName::HtmlFlowTagName)
     } else {
         tokenizer.tokenize_state.seen = false;
         tokenizer.tokenize_state.start = 0;
@@ -340,7 +340,7 @@ pub fn tag_name(tokenizer: &mut Tokenizer) -> State {
 
                 if slash {
                     tokenizer.consume();
-                    State::Fn(StateName::HtmlFlowBasicSelfClosing)
+                    State::Next(StateName::HtmlFlowBasicSelfClosing)
                 } else {
                     // Do not form containers.
                     tokenizer.concrete = true;
@@ -363,7 +363,7 @@ pub fn tag_name(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphanumerical and `-`.
         Some(b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowTagName)
+            State::Next(StateName::HtmlFlowTagName)
         }
         Some(_) => {
             tokenizer.tokenize_state.seen = false;
@@ -383,7 +383,7 @@ pub fn basic_self_closing(tokenizer: &mut Tokenizer) -> State {
         tokenizer.consume();
         // Do not form containers.
         tokenizer.concrete = true;
-        State::Fn(StateName::HtmlFlowContinuation)
+        State::Next(StateName::HtmlFlowContinuation)
     } else {
         tokenizer.tokenize_state.marker = 0;
         State::Nok
@@ -400,7 +400,7 @@ pub fn complete_closing_tag_after(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteClosingTagAfter)
+            State::Next(StateName::HtmlFlowCompleteClosingTagAfter)
         }
         _ => complete_end(tokenizer),
     }
@@ -429,16 +429,16 @@ pub fn complete_attribute_name_before(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeNameBefore)
+            State::Next(StateName::HtmlFlowCompleteAttributeNameBefore)
         }
         Some(b'/') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteEnd)
+            State::Next(StateName::HtmlFlowCompleteEnd)
         }
         // ASCII alphanumerical and `:` and `_`.
         Some(b'0'..=b'9' | b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeName)
+            State::Next(StateName::HtmlFlowCompleteAttributeName)
         }
         _ => complete_end(tokenizer),
     }
@@ -459,7 +459,7 @@ pub fn complete_attribute_name(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphanumerical and `-`, `.`, `:`, and `_`.
         Some(b'-' | b'.' | b'0'..=b'9' | b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeName)
+            State::Next(StateName::HtmlFlowCompleteAttributeName)
         }
         _ => complete_attribute_name_after(tokenizer),
     }
@@ -478,11 +478,11 @@ pub fn complete_attribute_name_after(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeNameAfter)
+            State::Next(StateName::HtmlFlowCompleteAttributeNameAfter)
         }
         Some(b'=') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueBefore)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueBefore)
         }
         _ => complete_attribute_name_before(tokenizer),
     }
@@ -505,12 +505,12 @@ pub fn complete_attribute_value_before(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueBefore)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueBefore)
         }
         Some(b'"' | b'\'') => {
             tokenizer.tokenize_state.marker_other = tokenizer.current.unwrap();
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueQuoted)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueQuoted)
         }
         _ => complete_attribute_value_unquoted(tokenizer),
     }
@@ -536,11 +536,11 @@ pub fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer) -> State {
         {
             tokenizer.tokenize_state.marker_other = 0;
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueQuotedAfter)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueQuotedAfter)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueQuoted)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueQuoted)
         }
     }
 }
@@ -558,7 +558,7 @@ pub fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer) -> State {
         }
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAttributeValueUnquoted)
+            State::Next(StateName::HtmlFlowCompleteAttributeValueUnquoted)
         }
     }
 }
@@ -588,7 +588,7 @@ pub fn complete_attribute_value_quoted_after(tokenizer: &mut Tokenizer) -> State
 pub fn complete_end(tokenizer: &mut Tokenizer) -> State {
     if let Some(b'>') = tokenizer.current {
         tokenizer.consume();
-        State::Fn(StateName::HtmlFlowCompleteAfter)
+        State::Next(StateName::HtmlFlowCompleteAfter)
     } else {
         tokenizer.tokenize_state.marker = 0;
         State::Nok
@@ -610,7 +610,7 @@ pub fn complete_after(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowCompleteAfter)
+            State::Next(StateName::HtmlFlowCompleteAfter)
         }
         Some(_) => {
             tokenizer.tokenize_state.marker = 0;
@@ -634,8 +634,8 @@ pub fn continuation(tokenizer: &mut Tokenizer) -> State {
             tokenizer.exit(Token::HtmlFlowData);
             tokenizer.check(
                 StateName::HtmlFlowBlankLineBefore,
-                State::Fn(StateName::HtmlFlowContinuationAfter),
-                State::Fn(StateName::HtmlFlowContinuationStart),
+                State::Next(StateName::HtmlFlowContinuationAfter),
+                State::Next(StateName::HtmlFlowContinuationStart),
             )
         }
         // Note: important that this is after the basic/complete case.
@@ -645,27 +645,27 @@ pub fn continuation(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'-') if tokenizer.tokenize_state.marker == COMMENT => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationCommentInside)
+            State::Next(StateName::HtmlFlowContinuationCommentInside)
         }
         Some(b'<') if tokenizer.tokenize_state.marker == RAW => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationRawTagOpen)
+            State::Next(StateName::HtmlFlowContinuationRawTagOpen)
         }
         Some(b'>') if tokenizer.tokenize_state.marker == DECLARATION => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationClose)
+            State::Next(StateName::HtmlFlowContinuationClose)
         }
         Some(b'?') if tokenizer.tokenize_state.marker == INSTRUCTION => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         Some(b']') if tokenizer.tokenize_state.marker == CDATA => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationCdataInside)
+            State::Next(StateName::HtmlFlowContinuationCdataInside)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuation)
+            State::Next(StateName::HtmlFlowContinuation)
         }
     }
 }
@@ -680,8 +680,8 @@ pub fn continuation(tokenizer: &mut Tokenizer) -> State {
 pub fn continuation_start(tokenizer: &mut Tokenizer) -> State {
     tokenizer.check(
         StateName::NonLazyContinuationStart,
-        State::Fn(StateName::HtmlFlowContinuationStartNonLazy),
-        State::Fn(StateName::HtmlFlowContinuationAfter),
+        State::Next(StateName::HtmlFlowContinuationStartNonLazy),
+        State::Next(StateName::HtmlFlowContinuationAfter),
     )
 }
 
@@ -698,7 +698,7 @@ pub fn continuation_start_non_lazy(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::HtmlFlowContinuationBefore)
+            State::Next(StateName::HtmlFlowContinuationBefore)
         }
         _ => unreachable!("expected eol"),
     }
@@ -731,7 +731,7 @@ pub fn continuation_comment_inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         _ => continuation(tokenizer),
     }
@@ -748,7 +748,7 @@ pub fn continuation_raw_tag_open(tokenizer: &mut Tokenizer) -> State {
         Some(b'/') => {
             tokenizer.consume();
             tokenizer.tokenize_state.start = tokenizer.point.index;
-            State::Fn(StateName::HtmlFlowContinuationRawEndTag)
+            State::Next(StateName::HtmlFlowContinuationRawEndTag)
         }
         _ => continuation(tokenizer),
     }
@@ -775,7 +775,7 @@ pub fn continuation_raw_end_tag(tokenizer: &mut Tokenizer) -> State {
 
             if HTML_RAW_NAMES.contains(&name.as_str()) {
                 tokenizer.consume();
-                State::Fn(StateName::HtmlFlowContinuationClose)
+                State::Next(StateName::HtmlFlowContinuationClose)
             } else {
                 continuation(tokenizer)
             }
@@ -784,7 +784,7 @@ pub fn continuation_raw_end_tag(tokenizer: &mut Tokenizer) -> State {
             if tokenizer.point.index - tokenizer.tokenize_state.start < HTML_RAW_SIZE_MAX =>
         {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationRawEndTag)
+            State::Next(StateName::HtmlFlowContinuationRawEndTag)
         }
         _ => {
             tokenizer.tokenize_state.start = 0;
@@ -803,7 +803,7 @@ pub fn continuation_cdata_inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b']') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         _ => continuation(tokenizer),
     }
@@ -827,11 +827,11 @@ pub fn continuation_declaration_inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'>') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationClose)
+            State::Next(StateName::HtmlFlowContinuationClose)
         }
         Some(b'-') if tokenizer.tokenize_state.marker == COMMENT => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationDeclarationInside)
+            State::Next(StateName::HtmlFlowContinuationDeclarationInside)
         }
         _ => continuation(tokenizer),
     }
@@ -851,7 +851,7 @@ pub fn continuation_close(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlFlowContinuationClose)
+            State::Next(StateName::HtmlFlowContinuationClose)
         }
     }
 }
@@ -883,5 +883,5 @@ pub fn blank_line_before(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::LineEnding);
     tokenizer.consume();
     tokenizer.exit(Token::LineEnding);
-    State::Fn(StateName::BlankLineStart)
+    State::Next(StateName::BlankLineStart)
 }
diff --git a/src/construct/html_text.rs b/src/construct/html_text.rs
index c1dfaca..38d0476 100644
--- a/src/construct/html_text.rs
+++ b/src/construct/html_text.rs
@@ -70,7 +70,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         tokenizer.enter(Token::HtmlText);
         tokenizer.enter(Token::HtmlTextData);
         tokenizer.consume();
-        State::Fn(StateName::HtmlTextOpen)
+        State::Next(StateName::HtmlTextOpen)
     } else {
         State::Nok
     }
@@ -90,20 +90,20 @@ pub fn open(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'!') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextDeclarationOpen)
+            State::Next(StateName::HtmlTextDeclarationOpen)
         }
         Some(b'/') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagCloseStart)
+            State::Next(StateName::HtmlTextTagCloseStart)
         }
         Some(b'?') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextInstruction)
+            State::Next(StateName::HtmlTextInstruction)
         }
         // ASCII alphabetical.
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpen)
+            State::Next(StateName::HtmlTextTagOpen)
         }
         _ => State::Nok,
     }
@@ -123,16 +123,16 @@ pub fn declaration_open(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCommentOpenInside)
+            State::Next(StateName::HtmlTextCommentOpenInside)
         }
         // ASCII alphabetical.
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextDeclaration)
+            State::Next(StateName::HtmlTextDeclaration)
         }
         Some(b'[') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCdataOpenInside)
+            State::Next(StateName::HtmlTextCdataOpenInside)
         }
         _ => State::Nok,
     }
@@ -148,7 +148,7 @@ pub fn comment_open_inside(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCommentStart)
+            State::Next(StateName::HtmlTextCommentStart)
         }
         _ => State::Nok,
     }
@@ -172,7 +172,7 @@ pub fn comment_start(tokenizer: &mut Tokenizer) -> State {
         Some(b'>') => State::Nok,
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCommentStartDash)
+            State::Next(StateName::HtmlTextCommentStartDash)
         }
         _ => comment(tokenizer),
     }
@@ -213,11 +213,11 @@ pub fn comment(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCommentClose)
+            State::Next(StateName::HtmlTextCommentClose)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextComment)
+            State::Next(StateName::HtmlTextComment)
         }
     }
 }
@@ -232,7 +232,7 @@ pub fn comment_close(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'-') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextEnd)
+            State::Next(StateName::HtmlTextEnd)
         }
         _ => comment(tokenizer),
     }
@@ -251,9 +251,9 @@ pub fn cdata_open_inside(tokenizer: &mut Tokenizer) -> State {
 
         if tokenizer.tokenize_state.size == HTML_CDATA_PREFIX.len() {
             tokenizer.tokenize_state.size = 0;
-            State::Fn(StateName::HtmlTextCdata)
+            State::Next(StateName::HtmlTextCdata)
         } else {
-            State::Fn(StateName::HtmlTextCdataOpenInside)
+            State::Next(StateName::HtmlTextCdataOpenInside)
         }
     } else {
         State::Nok
@@ -275,11 +275,11 @@ pub fn cdata(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b']') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCdataClose)
+            State::Next(StateName::HtmlTextCdataClose)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCdata)
+            State::Next(StateName::HtmlTextCdata)
         }
     }
 }
@@ -294,7 +294,7 @@ pub fn cdata_close(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b']') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextCdataEnd)
+            State::Next(StateName::HtmlTextCdataEnd)
         }
         _ => cdata(tokenizer),
     }
@@ -329,7 +329,7 @@ pub fn declaration(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextDeclaration)
+            State::Next(StateName::HtmlTextDeclaration)
         }
     }
 }
@@ -349,11 +349,11 @@ pub fn instruction(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'?') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextInstructionClose)
+            State::Next(StateName::HtmlTextInstructionClose)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextInstruction)
+            State::Next(StateName::HtmlTextInstruction)
         }
     }
 }
@@ -382,7 +382,7 @@ pub fn tag_close_start(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphabetical.
         Some(b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagClose)
+            State::Next(StateName::HtmlTextTagClose)
         }
         _ => State::Nok,
     }
@@ -399,7 +399,7 @@ pub fn tag_close(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphanumerical and `-`.
         Some(b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagClose)
+            State::Next(StateName::HtmlTextTagClose)
         }
         _ => tag_close_between(tokenizer),
     }
@@ -419,7 +419,7 @@ pub fn tag_close_between(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagCloseBetween)
+            State::Next(StateName::HtmlTextTagCloseBetween)
         }
         _ => end(tokenizer),
     }
@@ -436,7 +436,7 @@ pub fn tag_open(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphanumerical and `-`.
         Some(b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpen)
+            State::Next(StateName::HtmlTextTagOpen)
         }
         Some(b'\t' | b'\n' | b' ' | b'/' | b'>') => tag_open_between(tokenizer),
         _ => State::Nok,
@@ -457,16 +457,16 @@ pub fn tag_open_between(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenBetween)
+            State::Next(StateName::HtmlTextTagOpenBetween)
         }
         Some(b'/') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextEnd)
+            State::Next(StateName::HtmlTextEnd)
         }
         // ASCII alphabetical and `:` and `_`.
         Some(b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeName)
+            State::Next(StateName::HtmlTextTagOpenAttributeName)
         }
         _ => end(tokenizer),
     }
@@ -483,7 +483,7 @@ pub fn tag_open_attribute_name(tokenizer: &mut Tokenizer) -> State {
         // ASCII alphabetical and `-`, `.`, `:`, and `_`.
         Some(b'-' | b'.' | b'0'..=b'9' | b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeName)
+            State::Next(StateName::HtmlTextTagOpenAttributeName)
         }
         _ => tag_open_attribute_name_after(tokenizer),
     }
@@ -505,11 +505,11 @@ pub fn tag_open_attribute_name_after(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeNameAfter)
+            State::Next(StateName::HtmlTextTagOpenAttributeNameAfter)
         }
         Some(b'=') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueBefore)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueBefore)
         }
         _ => tag_open_between(tokenizer),
     }
@@ -532,16 +532,16 @@ pub fn tag_open_attribute_value_before(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\t' | b' ') => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueBefore)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueBefore)
         }
         Some(b'"' | b'\'') => {
             tokenizer.tokenize_state.marker = tokenizer.current.unwrap();
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueQuoted)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueQuoted)
         }
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueUnquoted)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueUnquoted)
         }
     }
 }
@@ -566,11 +566,11 @@ pub fn tag_open_attribute_value_quoted(tokenizer: &mut Tokenizer) -> State {
         Some(b'"' | b'\'') if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker => {
             tokenizer.tokenize_state.marker = 0;
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueQuotedAfter)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueQuotedAfter)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueQuoted)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueQuoted)
         }
     }
 }
@@ -587,7 +587,7 @@ pub fn tag_open_attribute_value_unquoted(tokenizer: &mut Tokenizer) -> State {
         Some(b'\t' | b'\n' | b' ' | b'/' | b'>') => tag_open_between(tokenizer),
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::HtmlTextTagOpenAttributeValueUnquoted)
+            State::Next(StateName::HtmlTextTagOpenAttributeValueUnquoted)
         }
     }
 }
@@ -641,7 +641,7 @@ pub fn line_ending_before(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::HtmlTextLineEndingAfter)
+            State::Next(StateName::HtmlTextLineEndingAfter)
         }
         _ => unreachable!("expected eol"),
     }
@@ -658,11 +658,11 @@ pub fn line_ending_before(tokenizer: &mut Tokenizer) -> State {
 ///     ^
 /// ```
 pub fn line_ending_after(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab(tokenizer);
+    let name = space_or_tab(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::HtmlTextLineEndingAfterPrefix),
-        State::Fn(StateName::HtmlTextLineEndingAfterPrefix),
+        name,
+        State::Next(StateName::HtmlTextLineEndingAfterPrefix),
+        State::Next(StateName::HtmlTextLineEndingAfterPrefix),
     )
 }
 
@@ -677,8 +677,9 @@ pub fn line_ending_after(tokenizer: &mut Tokenizer) -> State {
 ///     ^
 /// ```
 pub fn line_ending_after_prefix(tokenizer: &mut Tokenizer) -> State {
-    let state_name = tokenizer.tokenize_state.return_state.take().unwrap();
-    let func = state_name.to_func();
+    let name = tokenizer.tokenize_state.return_state.take().unwrap();
+    // To do: should use `State::Retry` when it exists.
+    let func = name.to_func();
     tokenizer.enter(Token::HtmlTextData);
     func(tokenizer)
 }
diff --git a/src/construct/label_end.rs b/src/construct/label_end.rs
index 47ded36..0404b6e 100644
--- a/src/construct/label_end.rs
+++ b/src/construct/label_end.rs
@@ -201,7 +201,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.consume();
             tokenizer.exit(Token::LabelMarker);
             tokenizer.exit(Token::LabelEnd);
-            return State::Fn(StateName::LabelEndAfter);
+            return State::Next(StateName::LabelEndAfter);
         }
     }
 
@@ -239,8 +239,8 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
         // Resource (`[asd](fgh)`)?
         Some(b'(') => tokenizer.attempt(
             StateName::LabelEndResourceStart,
-            State::Fn(StateName::LabelEndOk),
-            State::Fn(if defined {
+            State::Next(StateName::LabelEndOk),
+            State::Next(if defined {
                 StateName::LabelEndOk
             } else {
                 StateName::LabelEndNok
@@ -249,8 +249,8 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
         // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?
         Some(b'[') => tokenizer.attempt(
             StateName::LabelEndReferenceFull,
-            State::Fn(StateName::LabelEndOk),
-            State::Fn(if defined {
+            State::Next(StateName::LabelEndOk),
+            State::Next(if defined {
                 StateName::LabelEndReferenceNotFull
             } else {
                 StateName::LabelEndNok
@@ -278,8 +278,8 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
 pub fn reference_not_full(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::LabelEndReferenceCollapsed,
-        State::Fn(StateName::LabelEndOk),
-        State::Fn(StateName::LabelEndNok),
+        State::Next(StateName::LabelEndOk),
+        State::Next(StateName::LabelEndNok),
     )
 }
 
@@ -362,7 +362,7 @@ pub fn resource_start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::ResourceMarker);
             tokenizer.consume();
             tokenizer.exit(Token::ResourceMarker);
-            State::Fn(StateName::LabelEndResourceBefore)
+            State::Next(StateName::LabelEndResourceBefore)
         }
         _ => unreachable!("expected `(`"),
     }
@@ -375,11 +375,11 @@ pub fn resource_start(tokenizer: &mut Tokenizer) -> State {
 ///         ^
 /// ```
 pub fn resource_before(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_eol(tokenizer);
+    let name = space_or_tab_eol(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::LabelEndResourceOpen),
-        State::Fn(StateName::LabelEndResourceOpen),
+        name,
+        State::Next(StateName::LabelEndResourceOpen),
+        State::Next(StateName::LabelEndResourceOpen),
     )
 }
 
@@ -402,8 +402,8 @@ pub fn resource_open(tokenizer: &mut Tokenizer) -> State {
 
         tokenizer.attempt(
             StateName::DestinationStart,
-            State::Fn(StateName::LabelEndResourceDestinationAfter),
-            State::Fn(StateName::LabelEndResourceDestinationMissing),
+            State::Next(StateName::LabelEndResourceDestinationAfter),
+            State::Next(StateName::LabelEndResourceDestinationMissing),
         )
     }
 }
@@ -421,11 +421,11 @@ pub fn resource_destination_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.token_4 = Token::Data;
     tokenizer.tokenize_state.token_5 = Token::Data;
     tokenizer.tokenize_state.size_other = 0;
-    let state_name = space_or_tab_eol(tokenizer);
+    let name = space_or_tab_eol(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::LabelEndResourceBetween),
-        State::Fn(StateName::LabelEndResourceEnd),
+        name,
+        State::Next(StateName::LabelEndResourceBetween),
+        State::Next(StateName::LabelEndResourceEnd),
     )
 }
 
@@ -454,7 +454,7 @@ pub fn resource_between(tokenizer: &mut Tokenizer) -> State {
             tokenizer.tokenize_state.token_3 = Token::ResourceTitleString;
             tokenizer.attempt(
                 StateName::TitleStart,
-                State::Fn(StateName::LabelEndResourceTitleAfter),
+                State::Next(StateName::LabelEndResourceTitleAfter),
                 State::Nok,
             )
         }
@@ -472,11 +472,11 @@ pub fn resource_title_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.token_1 = Token::Data;
     tokenizer.tokenize_state.token_2 = Token::Data;
     tokenizer.tokenize_state.token_3 = Token::Data;
-    let state_name = space_or_tab_eol(tokenizer);
+    let name = space_or_tab_eol(tokenizer);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::LabelEndResourceEnd),
-        State::Fn(StateName::LabelEndResourceEnd),
+        name,
+        State::Next(StateName::LabelEndResourceEnd),
+        State::Next(StateName::LabelEndResourceEnd),
     )
 }
 
@@ -513,7 +513,7 @@ pub fn reference_full(tokenizer: &mut Tokenizer) -> State {
             tokenizer.tokenize_state.token_3 = Token::ReferenceString;
             tokenizer.attempt(
                 StateName::LabelStart,
-                State::Fn(StateName::LabelEndReferenceFullAfter),
+                State::Next(StateName::LabelEndReferenceFullAfter),
                 State::Nok,
             )
         }
@@ -572,7 +572,7 @@ pub fn reference_collapsed(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::ReferenceMarker);
             tokenizer.consume();
             tokenizer.exit(Token::ReferenceMarker);
-            State::Fn(StateName::LabelEndReferenceCollapsedOpen)
+            State::Next(StateName::LabelEndReferenceCollapsedOpen)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/label_start_image.rs b/src/construct/label_start_image.rs
index 4fcf8c2..1730fc3 100644
--- a/src/construct/label_start_image.rs
+++ b/src/construct/label_start_image.rs
@@ -45,7 +45,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LabelImageMarker);
             tokenizer.consume();
             tokenizer.exit(Token::LabelImageMarker);
-            State::Fn(StateName::LabelStartImageOpen)
+            State::Next(StateName::LabelStartImageOpen)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/list.rs b/src/construct/list.rs
index 9e4b105..1aec032 100644
--- a/src/construct/list.rs
+++ b/src/construct/list.rs
@@ -62,7 +62,7 @@ use crate::util::{
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.list {
         tokenizer.enter(Token::ListItem);
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -71,7 +71,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
                 usize::MAX
             },
         );
-        tokenizer.attempt(state_name, State::Fn(StateName::ListBefore), State::Nok)
+        tokenizer.attempt(name, State::Next(StateName::ListBefore), State::Nok)
     } else {
         State::Nok
     }
@@ -88,8 +88,8 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
         // Unordered.
         Some(b'*' | b'-') => tokenizer.check(
             StateName::ThematicBreakStart,
-            State::Fn(StateName::ListNok),
-            State::Fn(StateName::ListBeforeUnordered),
+            State::Next(StateName::ListNok),
+            State::Next(StateName::ListBeforeUnordered),
         ),
         Some(b'+') => before_unordered(tokenizer),
         // Ordered.
@@ -139,7 +139,7 @@ pub fn value(tokenizer: &mut Tokenizer) -> State {
         Some(b'0'..=b'9') if tokenizer.tokenize_state.size + 1 < LIST_ITEM_VALUE_SIZE_MAX => {
             tokenizer.tokenize_state.size += 1;
             tokenizer.consume();
-            State::Fn(StateName::ListValue)
+            State::Next(StateName::ListValue)
         }
         _ => {
             tokenizer.tokenize_state.size = 0;
@@ -160,7 +160,7 @@ pub fn marker(tokenizer: &mut Tokenizer) -> State {
     tokenizer.enter(Token::ListItemMarker);
     tokenizer.consume();
     tokenizer.exit(Token::ListItemMarker);
-    State::Fn(StateName::ListMarkerAfter)
+    State::Next(StateName::ListMarkerAfter)
 }
 
 /// After a list item marker.
@@ -175,8 +175,8 @@ pub fn marker_after(tokenizer: &mut Tokenizer) -> State {
     tokenizer.tokenize_state.size = 1;
     tokenizer.check(
         StateName::BlankLineStart,
-        State::Fn(StateName::ListAfter),
-        State::Fn(StateName::ListMarkerAfterFilled),
+        State::Next(StateName::ListAfter),
+        State::Next(StateName::ListMarkerAfterFilled),
     )
 }
 
@@ -192,8 +192,8 @@ pub fn marker_after_filled(tokenizer: &mut Tokenizer) -> State {
     // Attempt to parse up to the largest allowed indent, `nok` if there is more whitespace.
     tokenizer.attempt(
         StateName::ListWhitespace,
-        State::Fn(StateName::ListAfter),
-        State::Fn(StateName::ListPrefixOther),
+        State::Next(StateName::ListAfter),
+        State::Next(StateName::ListPrefixOther),
     )
 }
 
@@ -204,10 +204,10 @@ pub fn marker_after_filled(tokenizer: &mut Tokenizer) -> State {
 ///      ^
 /// ```
 pub fn whitespace(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_min_max(tokenizer, 1, TAB_SIZE);
+    let name = space_or_tab_min_max(tokenizer, 1, TAB_SIZE);
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::ListWhitespaceAfter),
+        name,
+        State::Next(StateName::ListWhitespaceAfter),
         State::Nok,
     )
 }
@@ -238,7 +238,7 @@ pub fn prefix_other(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::SpaceOrTab);
             tokenizer.consume();
             tokenizer.exit(Token::SpaceOrTab);
-            State::Fn(StateName::ListAfter)
+            State::Next(StateName::ListAfter)
         }
         _ => State::Nok,
     }
@@ -295,8 +295,8 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
 pub fn cont_start(tokenizer: &mut Tokenizer) -> State {
     tokenizer.check(
         StateName::BlankLineStart,
-        State::Fn(StateName::ListContBlank),
-        State::Fn(StateName::ListContFilled),
+        State::Next(StateName::ListContBlank),
+        State::Next(StateName::ListContFilled),
     )
 }
 
@@ -315,9 +315,9 @@ pub fn cont_blank(tokenizer: &mut Tokenizer) -> State {
     if container.blank_initial {
         State::Nok
     } else {
-        let state_name = space_or_tab_min_max(tokenizer, 0, size);
+        let name = space_or_tab_min_max(tokenizer, 0, size);
         // Consume, optionally, at most `size`.
-        tokenizer.attempt(state_name, State::Fn(StateName::ListOk), State::Nok)
+        tokenizer.attempt(name, State::Next(StateName::ListOk), State::Nok)
     }
 }
 
@@ -335,8 +335,8 @@ pub fn cont_filled(tokenizer: &mut Tokenizer) -> State {
     container.blank_initial = false;
 
     // Consume exactly `size`.
-    let state_name = space_or_tab_min_max(tokenizer, size, size);
-    tokenizer.attempt(state_name, State::Fn(StateName::ListOk), State::Nok)
+    let name = space_or_tab_min_max(tokenizer, size, size);
+    tokenizer.attempt(name, State::Next(StateName::ListOk), State::Nok)
 }
 
 /// A state fn to yield [`State::Ok`].
diff --git a/src/construct/paragraph.rs b/src/construct/paragraph.rs
index de750f4..cb3d85e 100644
--- a/src/construct/paragraph.rs
+++ b/src/construct/paragraph.rs
@@ -71,7 +71,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::ParagraphInside)
+            State::Next(StateName::ParagraphInside)
         }
     }
 }
diff --git a/src/construct/partial_bom.rs b/src/construct/partial_bom.rs
index b32b7f9..b2f6e1f 100644
--- a/src/construct/partial_bom.rs
+++ b/src/construct/partial_bom.rs
@@ -45,7 +45,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
             tokenizer.tokenize_state.size = 0;
             State::Ok
         } else {
-            State::Fn(StateName::BomInside)
+            State::Next(StateName::BomInside)
         }
     } else {
         tokenizer.tokenize_state.size = 0;
diff --git a/src/construct/partial_data.rs b/src/construct/partial_data.rs
index 1cb5e61..5450ff2 100644
--- a/src/construct/partial_data.rs
+++ b/src/construct/partial_data.rs
@@ -21,7 +21,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         Some(byte) if tokenizer.tokenize_state.stop.contains(&byte) => {
             tokenizer.enter(Token::Data);
             tokenizer.consume();
-            State::Fn(StateName::DataInside)
+            State::Next(StateName::DataInside)
         }
         _ => at_break(tokenizer),
     }
@@ -40,7 +40,7 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::DataAtBreak)
+            State::Next(StateName::DataAtBreak)
         }
         Some(byte) if tokenizer.tokenize_state.stop.contains(&byte) => {
             tokenizer.register_resolver_before("data".to_string(), Box::new(resolve_data));
@@ -71,7 +71,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
         at_break(tokenizer)
     } else {
         tokenizer.consume();
-        State::Fn(StateName::DataInside)
+        State::Next(StateName::DataInside)
     }
 }
 
diff --git a/src/construct/partial_destination.rs b/src/construct/partial_destination.rs
index e8818a0..e4cfdc3 100644
--- a/src/construct/partial_destination.rs
+++ b/src/construct/partial_destination.rs
@@ -90,7 +90,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(tokenizer.tokenize_state.token_3.clone());
             tokenizer.consume();
             tokenizer.exit(tokenizer.tokenize_state.token_3.clone());
-            State::Fn(StateName::DestinationEnclosedBefore)
+            State::Next(StateName::DestinationEnclosedBefore)
         }
         // ASCII control, space, closing paren, but *not* `\0`.
         None | Some(0x01..=0x1F | b' ' | b')' | 0x7F) => State::Nok,
@@ -141,11 +141,11 @@ pub fn enclosed(tokenizer: &mut Tokenizer) -> State {
         }
         Some(b'\\') => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationEnclosedEscape)
+            State::Next(StateName::DestinationEnclosedEscape)
         }
         _ => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationEnclosed)
+            State::Next(StateName::DestinationEnclosed)
         }
     }
 }
@@ -160,7 +160,7 @@ pub fn enclosed_escape(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'<' | b'>' | b'\\') => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationEnclosed)
+            State::Next(StateName::DestinationEnclosed)
         }
         _ => enclosed(tokenizer),
     }
@@ -185,7 +185,7 @@ pub fn raw(tokenizer: &mut Tokenizer) -> State {
         Some(b'(') if tokenizer.tokenize_state.size < tokenizer.tokenize_state.size_other => {
             tokenizer.consume();
             tokenizer.tokenize_state.size += 1;
-            State::Fn(StateName::DestinationRaw)
+            State::Next(StateName::DestinationRaw)
         }
         // ASCII control (but *not* `\0`) and space and `(`.
         None | Some(0x01..=0x1F | b' ' | b'(' | 0x7F) => {
@@ -195,15 +195,15 @@ pub fn raw(tokenizer: &mut Tokenizer) -> State {
         Some(b')') => {
             tokenizer.consume();
             tokenizer.tokenize_state.size -= 1;
-            State::Fn(StateName::DestinationRaw)
+            State::Next(StateName::DestinationRaw)
         }
         Some(b'\\') => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationRawEscape)
+            State::Next(StateName::DestinationRawEscape)
         }
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationRaw)
+            State::Next(StateName::DestinationRaw)
         }
     }
 }
@@ -218,7 +218,7 @@ pub fn raw_escape(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'(' | b')' | b'\\') => {
             tokenizer.consume();
-            State::Fn(StateName::DestinationRaw)
+            State::Next(StateName::DestinationRaw)
         }
         _ => raw(tokenizer),
     }
diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs
index 070bdc0..718af06 100644
--- a/src/construct/partial_label.rs
+++ b/src/construct/partial_label.rs
@@ -78,7 +78,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.consume();
             tokenizer.exit(tokenizer.tokenize_state.token_2.clone());
             tokenizer.enter(tokenizer.tokenize_state.token_3.clone());
-            State::Fn(StateName::LabelAtBreak)
+            State::Next(StateName::LabelAtBreak)
         }
         _ => State::Nok,
     }
@@ -102,7 +102,7 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
     } else {
         match tokenizer.current {
             Some(b'\n') => {
-                let state_name = space_or_tab_eol_with_options(
+                let name = space_or_tab_eol_with_options(
                     tokenizer,
                     EolOptions {
                         content_type: Some(ContentType::String),
@@ -110,9 +110,9 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
                     },
                 );
                 tokenizer.attempt(
-                    state_name,
-                    State::Fn(StateName::LabelEolAfter),
-                    State::Fn(StateName::LabelAtBlankLine),
+                    name,
+                    State::Next(StateName::LabelEolAfter),
+                    State::Next(StateName::LabelAtBlankLine),
                 )
             }
             Some(b']') => {
@@ -177,7 +177,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
                 if !tokenizer.tokenize_state.seen && !matches!(byte, b'\t' | b' ') {
                     tokenizer.tokenize_state.seen = true;
                 }
-                State::Fn(if matches!(byte, b'\\') {
+                State::Next(if matches!(byte, b'\\') {
                     StateName::LabelEscape
                 } else {
                     StateName::LabelInside
@@ -198,7 +198,7 @@ pub fn escape(tokenizer: &mut Tokenizer) -> State {
         Some(b'[' | b'\\' | b']') => {
             tokenizer.consume();
             tokenizer.tokenize_state.size += 1;
-            State::Fn(StateName::LabelInside)
+            State::Next(StateName::LabelInside)
         }
         _ => inside(tokenizer),
     }
diff --git a/src/construct/partial_non_lazy_continuation.rs b/src/construct/partial_non_lazy_continuation.rs
index 6d5cd7a..9d19860 100644
--- a/src/construct/partial_non_lazy_continuation.rs
+++ b/src/construct/partial_non_lazy_continuation.rs
@@ -26,7 +26,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::NonLazyContinuationAfter)
+            State::Next(StateName::NonLazyContinuationAfter)
         }
         _ => State::Nok,
     }
diff --git a/src/construct/partial_space_or_tab.rs b/src/construct/partial_space_or_tab.rs
index 0b63b0e..1ca2520 100644
--- a/src/construct/partial_space_or_tab.rs
+++ b/src/construct/partial_space_or_tab.rs
@@ -133,7 +133,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
         {
             tokenizer.consume();
             tokenizer.tokenize_state.space_or_tab_size += 1;
-            State::Fn(StateName::SpaceOrTabInside)
+            State::Next(StateName::SpaceOrTabInside)
         }
         _ => {
             tokenizer.exit(tokenizer.tokenize_state.space_or_tab_token.clone());
@@ -166,7 +166,7 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
 }
 
 pub fn eol_start(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_with_options(
+    let name = space_or_tab_with_options(
         tokenizer,
         Options {
             kind: Token::SpaceOrTab,
@@ -181,9 +181,9 @@ pub fn eol_start(tokenizer: &mut Tokenizer) -> State {
     );
 
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::SpaceOrTabEolAfterFirst),
-        State::Fn(StateName::SpaceOrTabEolAtEol),
+        name,
+        State::Next(StateName::SpaceOrTabEolAfterFirst),
+        State::Next(StateName::SpaceOrTabEolAtEol),
     )
 }
 
@@ -231,7 +231,7 @@ pub fn eol_at_eol(tokenizer: &mut Tokenizer) -> State {
 
         tokenizer.consume();
         tokenizer.exit(Token::LineEnding);
-        State::Fn(StateName::SpaceOrTabEolAfterEol)
+        State::Next(StateName::SpaceOrTabEolAfterEol)
     } else {
         let ok = tokenizer.tokenize_state.space_or_tab_eol_ok;
         tokenizer.tokenize_state.space_or_tab_eol_content_type = None;
@@ -254,7 +254,7 @@ pub fn eol_at_eol(tokenizer: &mut Tokenizer) -> State {
 /// ```
 #[allow(clippy::needless_pass_by_value)]
 pub fn eol_after_eol(tokenizer: &mut Tokenizer) -> State {
-    let state_name = space_or_tab_with_options(
+    let name = space_or_tab_with_options(
         tokenizer,
         Options {
             kind: Token::SpaceOrTab,
@@ -268,9 +268,9 @@ pub fn eol_after_eol(tokenizer: &mut Tokenizer) -> State {
         },
     );
     tokenizer.attempt(
-        state_name,
-        State::Fn(StateName::SpaceOrTabEolAfterMore),
-        State::Fn(StateName::SpaceOrTabEolAfterMore),
+        name,
+        State::Next(StateName::SpaceOrTabEolAfterMore),
+        State::Next(StateName::SpaceOrTabEolAfterMore),
     )
 }
 
diff --git a/src/construct/partial_title.rs b/src/construct/partial_title.rs
index 1d3e9b2..9521d32 100644
--- a/src/construct/partial_title.rs
+++ b/src/construct/partial_title.rs
@@ -50,7 +50,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(tokenizer.tokenize_state.token_2.clone());
             tokenizer.consume();
             tokenizer.exit(tokenizer.tokenize_state.token_2.clone());
-            State::Fn(StateName::TitleBegin)
+            State::Next(StateName::TitleBegin)
         }
         _ => State::Nok,
     }
@@ -98,7 +98,7 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
             State::Nok
         }
         Some(b'\n') => {
-            let state_name = space_or_tab_eol_with_options(
+            let name = space_or_tab_eol_with_options(
                 tokenizer,
                 EolOptions {
                     content_type: Some(ContentType::String),
@@ -107,9 +107,9 @@ pub fn at_break(tokenizer: &mut Tokenizer) -> State {
             );
 
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::TitleAfterEol),
-                State::Fn(StateName::TitleAtBlankLine),
+                name,
+                State::Next(StateName::TitleAfterEol),
+                State::Next(StateName::TitleAtBlankLine),
             )
         }
         Some(b'"' | b'\'' | b')')
@@ -166,7 +166,7 @@ pub fn inside(tokenizer: &mut Tokenizer) -> State {
         }
         Some(byte) => {
             tokenizer.consume();
-            State::Fn(if matches!(byte, b'\\') {
+            State::Next(if matches!(byte, b'\\') {
                 StateName::TitleEscape
             } else {
                 StateName::TitleInside
@@ -185,7 +185,7 @@ pub fn escape(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'"' | b'\'' | b')') => {
             tokenizer.consume();
-            State::Fn(StateName::TitleInside)
+            State::Next(StateName::TitleInside)
         }
         _ => inside(tokenizer),
     }
diff --git a/src/construct/thematic_break.rs b/src/construct/thematic_break.rs
index 30fabe4..beefe5b 100644
--- a/src/construct/thematic_break.rs
+++ b/src/construct/thematic_break.rs
@@ -62,7 +62,7 @@ use crate::tokenizer::{State, StateName, Tokenizer};
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if tokenizer.parse_state.constructs.thematic_break {
         tokenizer.enter(Token::ThematicBreak);
-        let state_name = space_or_tab_min_max(
+        let name = space_or_tab_min_max(
             tokenizer,
             0,
             if tokenizer.parse_state.constructs.code_indented {
@@ -73,8 +73,8 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         );
 
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::ThematicBreakBefore),
+            name,
+            State::Next(StateName::ThematicBreakBefore),
             State::Nok,
         )
     } else {
@@ -141,15 +141,15 @@ pub fn sequence(tokenizer: &mut Tokenizer) -> State {
         {
             tokenizer.consume();
             tokenizer.tokenize_state.size += 1;
-            State::Fn(StateName::ThematicBreakSequence)
+            State::Next(StateName::ThematicBreakSequence)
         }
         _ => {
             tokenizer.exit(Token::ThematicBreakSequence);
-            let state_name = space_or_tab(tokenizer);
+            let name = space_or_tab(tokenizer);
             tokenizer.attempt(
-                state_name,
-                State::Fn(StateName::ThematicBreakAtBreak),
-                State::Fn(StateName::ThematicBreakAtBreak),
+                name,
+                State::Next(StateName::ThematicBreakAtBreak),
+                State::Next(StateName::ThematicBreakAtBreak),
             )
         }
     }
diff --git a/src/content/document.rs b/src/content/document.rs
index 2c340f2..5ce4dc4 100644
--- a/src/content/document.rs
+++ b/src/content/document.rs
@@ -105,11 +105,11 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
         tokenizer.point.clone(),
         tokenizer.parse_state,
     )));
-    tokenizer.tokenize_state.document_child_state = Some(State::Fn(StateName::FlowStart));
+    tokenizer.tokenize_state.document_child_state = Some(State::Next(StateName::FlowStart));
     tokenizer.attempt(
         StateName::BomStart,
-        State::Fn(StateName::DocumentLineStart),
-        State::Fn(StateName::DocumentLineStart),
+        State::Next(StateName::DocumentLineStart),
+        State::Next(StateName::DocumentLineStart),
     )
 }
 
@@ -144,16 +144,16 @@ pub fn container_existing_before(tokenizer: &mut Tokenizer) -> State {
             .tokenize_state
             .document_container_stack
             .remove(tokenizer.tokenize_state.document_continued);
-        let state_name = match container.kind {
+        let name = match container.kind {
             Container::BlockQuote => StateName::BlockQuoteContStart,
             Container::ListItem => StateName::ListContStart,
         };
 
         tokenizer.container = Some(container);
         tokenizer.attempt(
-            state_name,
-            State::Fn(StateName::DocumentContainerExistingAfter),
-            State::Fn(StateName::DocumentContainerExistingMissing),
+            name,
+            State::Next(StateName::DocumentContainerExistingAfter),
+            State::Next(StateName::DocumentContainerExistingMissing),
         )
     }
     // Otherwise, check new containers.
@@ -239,8 +239,8 @@ pub fn container_new_before(tokenizer: &mut Tokenizer) -> State {
 
     tokenizer.attempt(
         StateName::BlockQuoteStart,
-        State::Fn(StateName::DocumentContainerNewAfter),
-        State::Fn(StateName::DocumentContainerNewBeforeNotBlockQuote),
+        State::Next(StateName::DocumentContainerNewAfter),
+        State::Next(StateName::DocumentContainerNewBeforeNotBlockQuote),
     )
 }
 
@@ -255,8 +255,8 @@ pub fn container_new_before_not_block_quote(tokenizer: &mut Tokenizer) -> State
 
     tokenizer.attempt(
         StateName::ListStart,
-        State::Fn(StateName::DocumentContainerNewAfter),
-        State::Fn(StateName::DocumentContainersAfter),
+        State::Next(StateName::DocumentContainerNewAfter),
+        State::Next(StateName::DocumentContainersAfter),
     )
 }
 
@@ -340,11 +340,11 @@ pub fn flow_inside(tokenizer: &mut Tokenizer) -> State {
         Some(b'\n') => {
             tokenizer.consume();
             tokenizer.exit(Token::Data);
-            State::Fn(StateName::DocumentFlowEnd)
+            State::Next(StateName::DocumentFlowEnd)
         }
         Some(_) => {
             tokenizer.consume();
-            State::Fn(StateName::DocumentFlowInside)
+            State::Next(StateName::DocumentFlowInside)
         }
     }
 }
@@ -371,10 +371,10 @@ pub fn flow_end(tokenizer: &mut Tokenizer) -> State {
             .tokenize_state
             .document_child_state
             .take()
-            .unwrap_or(State::Fn(StateName::FlowStart));
+            .unwrap_or(State::Next(StateName::FlowStart));
 
-        let state_name = match state {
-            State::Fn(state_name) => state_name,
+        let name = match state {
+            State::Next(name) => name,
             _ => unreachable!("expected state name"),
         };
 
@@ -382,10 +382,10 @@ pub fn flow_end(tokenizer: &mut Tokenizer) -> State {
             // To do: handle VS?
             // if position.start.vs > 0 {
             // }
-            let state = child.push(position.start.index, position.end.index, state_name);
+            let state = child.push(position.start.index, position.end.index, name);
 
             interrupt = child.interrupt;
-            paragraph = matches!(state, State::Fn(StateName::ParagraphInside))
+            paragraph = matches!(state, State::Next(StateName::ParagraphInside))
                 || (!child.events.is_empty()
                     && child.events[skip::opt_back(
                         &child.events,
@@ -439,7 +439,7 @@ fn exit_containers(tokenizer: &mut Tokenizer, phase: &Phase) {
                 .tokenize_state
                 .document_child_state
                 .take()
-                .unwrap_or(State::Fn(StateName::FlowStart));
+                .unwrap_or(State::Next(StateName::FlowStart));
 
             child.flush(state, false);
         }
diff --git a/src/content/flow.rs b/src/content/flow.rs
index b3fb866..cd913c6 100644
--- a/src/content/flow.rs
+++ b/src/content/flow.rs
@@ -36,41 +36,41 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         Some(b'`' | b'~') => tokenizer.attempt(
             StateName::CodeFencedStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         Some(b'<') => tokenizer.attempt(
             StateName::HtmlFlowStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         Some(b'#') => tokenizer.attempt(
             StateName::HeadingAtxStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         // Note: `-` is also used in thematic breaks, so it’s not included here.
         Some(b'=') => tokenizer.attempt(
             StateName::HeadingSetextStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         Some(b'*' | b'_') => tokenizer.attempt(
             StateName::ThematicBreakStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         Some(b'[') => tokenizer.attempt(
             StateName::DefinitionStart,
-            State::Fn(StateName::FlowAfter),
-            State::Fn(StateName::FlowBeforeParagraph),
+            State::Next(StateName::FlowAfter),
+            State::Next(StateName::FlowBeforeParagraph),
         ),
         // Actual parsing: blank line? Indented code? Indented anything?
         // Also includes `-` which can be a setext heading underline or a thematic break.
         None | Some(b'\t' | b'\n' | b' ' | b'-') => before_blank_line(tokenizer),
         Some(_) => tokenizer.attempt(
             StateName::ParagraphStart,
-            State::Fn(StateName::FlowAfter),
+            State::Next(StateName::FlowAfter),
             State::Nok,
         ),
     }
@@ -79,8 +79,8 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
 pub fn before_blank_line(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::BlankLineStart,
-        State::Fn(StateName::FlowBlankLineAfter),
-        State::Fn(StateName::FlowBeforeCodeIndented),
+        State::Next(StateName::FlowBlankLineAfter),
+        State::Next(StateName::FlowBeforeCodeIndented),
     )
 }
 
@@ -99,56 +99,56 @@ pub fn before_blank_line(tokenizer: &mut Tokenizer) -> State {
 pub fn before_code_indented(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::CodeIndentedStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeCodeFenced),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeCodeFenced),
     )
 }
 
 pub fn before_code_fenced(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::CodeFencedStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeHtml),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeHtml),
     )
 }
 
 pub fn before_html(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::HtmlFlowStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeHeadingAtx),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeHeadingAtx),
     )
 }
 
 pub fn before_heading_atx(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::HeadingAtxStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeHeadingSetext),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeHeadingSetext),
     )
 }
 
 pub fn before_heading_setext(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::HeadingSetextStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeThematicBreak),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeThematicBreak),
     )
 }
 
 pub fn before_thematic_break(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::ThematicBreakStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeDefinition),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeDefinition),
     )
 }
 
 pub fn before_definition(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::DefinitionStart,
-        State::Fn(StateName::FlowAfter),
-        State::Fn(StateName::FlowBeforeParagraph),
+        State::Next(StateName::FlowAfter),
+        State::Next(StateName::FlowBeforeParagraph),
     )
 }
 
@@ -168,7 +168,7 @@ pub fn blank_line_after(tokenizer: &mut Tokenizer) -> State {
             tokenizer.exit(Token::BlankLineEnding);
             // Feel free to interrupt.
             tokenizer.interrupt = false;
-            State::Fn(StateName::FlowStart)
+            State::Next(StateName::FlowStart)
         }
         _ => unreachable!("expected eol/eof"),
     }
@@ -190,7 +190,7 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
             tokenizer.enter(Token::LineEnding);
             tokenizer.consume();
             tokenizer.exit(Token::LineEnding);
-            State::Fn(StateName::FlowStart)
+            State::Next(StateName::FlowStart)
         }
         _ => unreachable!("expected eol/eof"),
     }
@@ -204,7 +204,7 @@ pub fn after(tokenizer: &mut Tokenizer) -> State {
 pub fn before_paragraph(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::ParagraphStart,
-        State::Fn(StateName::FlowAfter),
+        State::Next(StateName::FlowAfter),
         State::Nok,
     )
 }
diff --git a/src/content/string.rs b/src/content/string.rs
index b3df6ec..fda9b51 100644
--- a/src/content/string.rs
+++ b/src/content/string.rs
@@ -30,13 +30,13 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
         None => State::Ok,
         Some(b'&') => tokenizer.attempt(
             StateName::CharacterReferenceStart,
-            State::Fn(StateName::StringBefore),
-            State::Fn(StateName::StringBeforeData),
+            State::Next(StateName::StringBefore),
+            State::Next(StateName::StringBeforeData),
         ),
         Some(b'\\') => tokenizer.attempt(
             StateName::CharacterEscapeStart,
-            State::Fn(StateName::StringBefore),
-            State::Fn(StateName::StringBeforeData),
+            State::Next(StateName::StringBefore),
+            State::Next(StateName::StringBeforeData),
         ),
         _ => before_data(tokenizer),
     }
@@ -46,7 +46,7 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
 pub fn before_data(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::DataStart,
-        State::Fn(StateName::StringBefore),
+        State::Next(StateName::StringBefore),
         State::Nok,
     )
 }
diff --git a/src/content/text.rs b/src/content/text.rs
index ff8c9eb..eb5a231 100644
--- a/src/content/text.rs
+++ b/src/content/text.rs
@@ -48,44 +48,44 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
         None => State::Ok,
         Some(b'!') => tokenizer.attempt(
             StateName::LabelStartImageStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         Some(b'&') => tokenizer.attempt(
             StateName::CharacterReferenceStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         Some(b'*' | b'_') => tokenizer.attempt(
             StateName::AttentionStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         // `autolink`, `html_text` (order does not matter)
         Some(b'<') => tokenizer.attempt(
             StateName::AutolinkStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeHtml),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeHtml),
         ),
         Some(b'[') => tokenizer.attempt(
             StateName::LabelStartLinkStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         Some(b'\\') => tokenizer.attempt(
             StateName::CharacterEscapeStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeHardBreakEscape),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeHardBreakEscape),
         ),
         Some(b']') => tokenizer.attempt(
             StateName::LabelEndStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         Some(b'`') => tokenizer.attempt(
             StateName::CodeTextStart,
-            State::Fn(StateName::TextBefore),
-            State::Fn(StateName::TextBeforeData),
+            State::Next(StateName::TextBefore),
+            State::Next(StateName::TextBeforeData),
         ),
         _ => before_data(tokenizer),
     }
@@ -95,8 +95,8 @@ pub fn before(tokenizer: &mut Tokenizer) -> State {
 pub fn before_html(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::HtmlTextStart,
-        State::Fn(StateName::TextBefore),
-        State::Fn(StateName::TextBeforeData),
+        State::Next(StateName::TextBefore),
+        State::Next(StateName::TextBeforeData),
     )
 }
 
@@ -104,8 +104,8 @@ pub fn before_html(tokenizer: &mut Tokenizer) -> State {
 pub fn before_hard_break_escape(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::HardBreakEscapeStart,
-        State::Fn(StateName::TextBefore),
-        State::Fn(StateName::TextBeforeData),
+        State::Next(StateName::TextBefore),
+        State::Next(StateName::TextBeforeData),
     )
 }
 
@@ -117,7 +117,7 @@ pub fn before_hard_break_escape(tokenizer: &mut Tokenizer) -> State {
 pub fn before_data(tokenizer: &mut Tokenizer) -> State {
     tokenizer.attempt(
         StateName::DataStart,
-        State::Fn(StateName::TextBefore),
+        State::Next(StateName::TextBefore),
         State::Nok,
     )
 }
diff --git a/src/subtokenize.rs b/src/subtokenize.rs
index 10f34d0..e0465a0 100644
--- a/src/subtokenize.rs
+++ b/src/subtokenize.rs
@@ -78,7 +78,7 @@ pub fn subtokenize(events: &mut Vec<Event>, parse_state: &ParseState) -> bool {
                 // Subtokenizer.
                 let mut tokenizer = Tokenizer::new(event.point.clone(), parse_state);
                 // Substate.
-                let mut state = State::Fn(if link.content_type == ContentType::String {
+                let mut state = State::Next(if link.content_type == ContentType::String {
                     StateName::StringStart
                 } else {
                     StateName::TextStart
@@ -98,7 +98,7 @@ pub fn subtokenize(events: &mut Vec<Event>, parse_state: &ParseState) -> bool {
                         enter.point.index,
                         events[index + 1].point.index,
                         match state {
-                            State::Fn(func) => func,
+                            State::Next(func) => func,
                             _ => unreachable!("cannot be ok/nok"),
                         },
                     );
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index 44b9f70..0efbfd6 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -735,7 +735,7 @@ impl StateName {
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub enum State {
     /// There is a future state: a [`StateName`][] to pass the next code to.
-    Fn(StateName),
+    Next(StateName),
     /// The state is successful.
     Ok,
     /// The state is not successful.
@@ -1208,32 +1208,32 @@ impl<'a> Tokenizer<'a> {
         self.stack.truncate(previous.stack_len);
     }
 
-    /// Parse with `state_name` and its future states, to check if it result in
+    /// Parse with `name` and its future states, to check if it result in
     /// [`State::Ok`][] or [`State::Nok`][], revert on both cases, and then
     /// call `done` with whether it was successful or not.
     ///
     /// This captures the current state of the tokenizer, returns a wrapped
-    /// state that captures all codes and feeds them to `state_name` and its
+    /// state that captures all codes and feeds them to `name` and its
     /// future states until it yields `State::Ok` or `State::Nok`.
     /// It then applies the captured state, calls `done`, and feeds all
     /// captured codes to its future states.
-    pub fn check(&mut self, state_name: StateName, ok: State, nok: State) -> State {
-        attempt_impl(self, state_name, ok, nok, AttemptKind::Check)
+    pub fn check(&mut self, name: StateName, ok: State, nok: State) -> State {
+        attempt_impl(self, name, ok, nok, AttemptKind::Check)
     }
 
-    /// Parse with `state_name` and its future states, to check if it results in
+    /// Parse with `name` and its future states, to check if it results in
     /// [`State::Ok`][] or [`State::Nok`][], revert on the case of
     /// `State::Nok`, and then call `done` with whether it was successful or
     /// not.
     ///
     /// This captures the current state of the tokenizer, returns a wrapped
-    /// state that captures all codes and feeds them to `state_name` and its
+    /// state that captures all codes and feeds them to `name` and its
     /// future states until it yields `State::Ok`, at which point it calls
     /// `done` and yields its result.
     /// If instead `State::Nok` was yielded, the captured state is applied,
     /// `done` is called, and all captured codes are fed to its future states.
-    pub fn attempt(&mut self, state_name: StateName, ok: State, nok: State) -> State {
-        attempt_impl(self, state_name, ok, nok, AttemptKind::Attempt)
+    pub fn attempt(&mut self, name: StateName, ok: State, nok: State) -> State {
+        attempt_impl(self, name, ok, nok, AttemptKind::Attempt)
     }
 
     /// Feed a list of `codes` into `start`.
@@ -1241,14 +1241,14 @@ impl<'a> Tokenizer<'a> {
     /// This is set up to support repeatedly calling `feed`, and thus streaming
     /// markdown into the state machine, and normally pauses after feeding.
     // Note: if needed: accept `vs`?
-    pub fn push(&mut self, min: usize, max: usize, state_name: StateName) -> State {
+    pub fn push(&mut self, min: usize, max: usize, name: StateName) -> State {
         debug_assert!(!self.resolved, "cannot feed after drain");
         // debug_assert!(min >= self.point.index, "cannot move backwards");
         if min > self.point.index {
             self.move_to((min, 0));
         }
 
-        let mut state = State::Fn(state_name);
+        let mut state = State::Next(name);
 
         while self.point.index < max {
             match state {
@@ -1259,9 +1259,9 @@ impl<'a> Tokenizer<'a> {
                         break;
                     }
                 }
-                State::Fn(state_name) => {
+                State::Next(name) => {
                     let action = byte_action(self.parse_state.bytes, &self.point);
-                    state = feed_action_impl(self, &Some(action), state_name);
+                    state = feed_action_impl(self, &Some(action), name);
                 }
             }
         }
@@ -1284,7 +1284,7 @@ impl<'a> Tokenizer<'a> {
                         break;
                     }
                 }
-                State::Fn(state_name) => {
+                State::Next(name) => {
                     // We sometimes move back when flushing, so then we use those codes.
                     state = feed_action_impl(
                         self,
@@ -1293,7 +1293,7 @@ impl<'a> Tokenizer<'a> {
                         } else {
                             Some(byte_action(self.parse_state.bytes, &self.point))
                         },
-                        state_name,
+                        name,
                     );
                 }
             }
@@ -1362,7 +1362,7 @@ fn byte_action(bytes: &[u8], point: &Point) -> ByteAction {
 /// Used in [`Tokenizer::attempt`][Tokenizer::attempt] and  [`Tokenizer::check`][Tokenizer::check].
 fn attempt_impl(
     tokenizer: &mut Tokenizer,
-    state_name: StateName,
+    name: StateName,
     ok: State,
     nok: State,
     kind: AttemptKind,
@@ -1383,7 +1383,7 @@ fn attempt_impl(
         state,
     });
 
-    call_impl(tokenizer, state_name)
+    call_impl(tokenizer, name)
 }
 
 fn attempt_done_impl(tokenizer: &mut Tokenizer, attempt: Attempt, state: State) -> State {
@@ -1404,11 +1404,11 @@ fn attempt_done_impl(tokenizer: &mut Tokenizer, attempt: Attempt, state: State)
 fn feed_action_impl(
     tokenizer: &mut Tokenizer,
     action: &Option<ByteAction>,
-    state_name: StateName,
+    name: StateName,
 ) -> State {
     if let Some(ByteAction::Ignore) = action {
         tokenizer.move_one();
-        State::Fn(state_name)
+        State::Next(name)
     } else {
         let byte = if let Some(ByteAction::Insert(byte) | ByteAction::Normal(byte)) = action {
             Some(*byte)
@@ -1420,16 +1420,16 @@ fn feed_action_impl(
             "main: flushing: `{:?}` ({:?}) to {:?}",
             byte,
             tokenizer.point,
-            state_name
+            name
         );
         tokenizer.expect(byte);
-        call_impl(tokenizer, state_name)
+        call_impl(tokenizer, name)
     }
 }
 
 #[allow(clippy::too_many_lines)]
-fn call_impl(tokenizer: &mut Tokenizer, state_name: StateName) -> State {
-    let func = state_name.to_func();
+fn call_impl(tokenizer: &mut Tokenizer, name: StateName) -> State {
+    let func = name.to_func();
 
     func(tokenizer)
 }