Enum Block 

pub enum Block {
    Paragraph(Vec<Inline>),
    Heading(Heading),
    ThematicBreak,
    BlockQuote(Vec<Block>),
    List(List),
    CodeBlock(CodeBlock),
    HtmlBlock(String),
    Definition(LinkDefinition),
    Table(Table),
    FootnoteDefinition(FootnoteDefinition),
    GitHubAlert(GitHubAlert),
    Empty,
}

Block‑level constructs in the order they appear in the CommonMark spec.

Variants

Paragraph(Vec<Inline>)

Ordinary paragraph

Heading(Heading)

ATX (# Heading) or Setext (===) heading

ThematicBreak

Thematic break (horizontal rule)

BlockQuote(Vec<Block>)

Block quote

List(List)

List (bullet or ordered)

CodeBlock(CodeBlock)

Fenced or indented code block

HtmlBlock(String)

Raw HTML block

Definition(LinkDefinition)

Link reference definition. Preserved for round‑tripping.

Table(Table)

Tables

FootnoteDefinition(FootnoteDefinition)

Footnote definition

GitHubAlert(GitHubAlert)

GitHub alert block (NOTE, TIP, IMPORTANT, WARNING, CAUTION)

Empty

Empty block. This is used to represent skipped blocks in the AST.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Block

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExpandWith for Block

fn expand_with<T: Transformer>(self, transformer: &mut T) -> Vec<Self>

Apply an expandable transformer to this AST node, returning multiple nodes

impl PartialEq for Block

fn eq(&self, other: &Block) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Query for Block

fn find_all_inlines<F>(&self, predicate: F) -> Vec<&Inline>

where F: Fn(&Inline) -> bool,

Find all inline elements matching a predicate

fn find_all_blocks<F>(&self, predicate: F) -> Vec<&Block>

where F: Fn(&Block) -> bool,

Find all block elements matching a predicate

fn find_first_inline<F>(&self, predicate: F) -> Option<&Inline>

where F: Fn(&Inline) -> bool,

Find the first inline element matching a predicate

fn find_first_block<F>(&self, predicate: F) -> Option<&Block>

where F: Fn(&Block) -> bool,

Find the first block element matching a predicate

fn count_inlines<F>(&self, predicate: F) -> usize

where F: Fn(&Inline) -> bool,

Count inline elements matching a predicate

fn count_blocks<F>(&self, predicate: F) -> usize

where F: Fn(&Block) -> bool,

Count block elements matching a predicate

fn any_inline<F>(&self, predicate: F) -> bool

where F: Fn(&Inline) -> bool,

Check if any inline element matches a predicate

fn any_block<F>(&self, predicate: F) -> bool

where F: Fn(&Block) -> bool,

Check if any block element matches a predicate

fn find_all_links(&self) -> Vec<&Link>

Find all links in the document

fn find_all_images(&self) -> Vec<&Image>

Find all images in the document

fn find_all_headings(&self) -> Vec<&Heading>

Find all headings in the document

fn find_all_autolinks(&self) -> Vec<&str>

Find all autolinks in the document

fn find_all_text(&self) -> Vec<&str>

Find all text nodes in the document

fn find_all_code_spans(&self) -> Vec<&str>

Find all code spans in the document

fn find_all_code_blocks(&self) -> Vec<&CodeBlock>

Find all code blocks in the document

fn find_all_tables(&self) -> Vec<&Table>

Find all tables in the document

fn find_all_lists(&self) -> Vec<&List>

Find all lists in the document

impl Serialize for Block

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TransformWith for Block

fn transform_with<T: Transformer>(self, transformer: &mut T) -> Self

Apply a transformer to this AST node

impl VisitWith for Block

fn visit_with<V: Visitor>(&self, visitor: &mut V)

Apply a visitor to this AST node

impl<T: Default> WithData<T> for Block

type WithDataType = Block<T>

The type with user data attached

fn with_data(self, data: T) -> Self::WithDataType

Add user data to this AST node

fn with_default_data(self) -> Self::WithDataType

where T: Default,

Add default user data to this AST node

impl StructuralPartialEq for Block