Search results

There are no results.

markdown.Node

class pub enum Node

A node in a Markdown AST.

Constructors

Block

Block(String, Array[Node])

A custom block/div/container.

The String argument is the tag/class of the block.

Span

Span(String, Array[Node])

A custom span with a tag.

The String argument is the tag/class of the span.

Quote

Quote(Array[Node])

A block quote.

Emphasis

Emphasis(Array[Node])

A regular emphasis node.

Paragraph

Paragraph(Array[Node])

A paragraph node.

Strong

Strong(Array[Node])

A strong emphasis node.

CodeSpan

CodeSpan(String)

An inline code span.

CodeBlock

CodeBlock(Option[String], String)

A code block with an optional info string.

Text

Text(String)

Regular text.

The String argument is the text value.

AutoLink(String)

An automatic link without any child nodes.

Link(Link, Array[Node])

A link with an optional body.

Image

Image(Link, String)

An image.

The second argument is the image text.

Heading

Heading(Int, Array[Node])

A heading.

The first argument is the heading level, in a range from 1 to 6. The second argument is the list of child nodes.

Footnote

Footnote(String)

A footnote.

The first argument is the name of the footnote.

UnorderedList

UnorderedList(Array[Node])

An unordered list.

OrderedList

OrderedList(Array[Node])

An ordered list.

ListItem

ListItem(Array[Node])

A single list item.

ThematicBreak

ThematicBreak()

A thematic break/horizontal ruler.

Superscript

Superscript(Array[Node])

A superscript node.

Subscript

Subscript(Array[Node])

A subscript node.

Table

Table(Array[Array[Array[Node]]], Array[Array[Array[Node]]], Array[Array[Array[Node]]])

A table.

The arguments are (in this order): the header rows, the body rows, and the footer rows. Each value is an array of rows, containing an array of columns, containing an array of markup nodes.

LineBreak

LineBreak()

A hard line break.

Comment

Comment(String)

A block comment.

Instance methods

!=

Show source code
Hide source code
fn pub !=(other: T) -> Bool {
  (self == other).false?
}
fn pub !=(other: T) -> Bool

Returns true if self and the given object are not equal to each other.

==

Show source code
Hide source code
fn pub ==(other: ref Node) -> Bool {
  match (self, other) {
    case (Block(a1, a2), Block(b1, b2)) -> a1 == b1 and a2 == b2
    case (Span(a1, a2), Span(b1, b2)) -> a1 == b1 and a2 == b2
    case (Quote(a), Quote(b)) -> a == b
    case (Emphasis(a), Emphasis(b)) -> a == b
    case (Paragraph(a), Paragraph(b)) -> a == b
    case (Strong(a), Strong(b)) -> a == b
    case (CodeSpan(a), CodeSpan(b)) -> a == b
    case (CodeBlock(a1, a2), CodeBlock(b1, b2)) -> a1 == b1 and a2 == b2
    case (Text(a), Text(b)) -> a == b
    case (AutoLink(a), AutoLink(b)) -> a == b
    case (Link(a1, a2), Link(b1, b2)) -> a1 == b1 and a2 == b2
    case (Image(a1, a2), Image(b1, b2)) -> a1 == b1 and a2 == b2
    case (Heading(a1, a2), Heading(b1, b2)) -> a1 == b1 and a2 == b2
    case (Footnote(a), Footnote(b)) -> a == b
    case (UnorderedList(a), UnorderedList(b)) -> a == b
    case (OrderedList(a), OrderedList(b)) -> a == b
    case (ListItem(a), ListItem(b)) -> a == b
    case (ThematicBreak, ThematicBreak) -> true
    case (Superscript(a), Superscript(b)) -> a == b
    case (Subscript(a), Subscript(b)) -> a == b
    case (Table(a1, a2, a3), Table(b1, b2, b3)) -> {
      a1 == b1 and a2 == b2 and a3 == b3
    }
    case (LineBreak, LineBreak) -> true
    case (Comment(a), Comment(b)) -> a == b
    case _ -> false
  }
}
fn pub ==(other: ref Node) -> Bool

Returns true if self and the given object are equal to each other.

This operator is used to perform structural equality. This means two objects residing in different memory locations may be considered equal, provided their structure is equal. For example, two different arrays may be considered to have structural equality if they contain the exact same values.

clone

Show source code
Hide source code
fn pub clone -> Node {
  match self {
    case Block(a, b) -> Node.Block(a, b.clone)
    case Span(a, b) -> Node.Span(a, b.clone)
    case Quote(v) -> Node.Quote(v.clone)
    case Emphasis(v) -> Node.Emphasis(v.clone)
    case Paragraph(v) -> Node.Paragraph(v.clone)
    case Strong(v) -> Node.Strong(v.clone)
    case CodeSpan(v) -> Node.CodeSpan(v)
    case CodeBlock(a, b) -> Node.CodeBlock(a.clone, b)
    case Text(v) -> Node.Text(v)
    case AutoLink(v) -> Node.AutoLink(v)
    case Link(a, b) -> Node.Link(a.clone, b.clone)
    case Image(a, b) -> Node.Image(a.clone, b)
    case Heading(a, b) -> Node.Heading(a, b.clone)
    case Footnote(v) -> Node.Footnote(v)
    case UnorderedList(v) -> Node.UnorderedList(v.clone)
    case OrderedList(v) -> Node.OrderedList(v.clone)
    case ListItem(v) -> Node.ListItem(v.clone)
    case ThematicBreak -> Node.ThematicBreak
    case Superscript(v) -> Node.Superscript(v.clone)
    case Subscript(v) -> Node.Subscript(v.clone)
    case Table(a, b, c) -> Node.Table(a.clone, b.clone, c.clone)
    case LineBreak -> Node.LineBreak
    case Comment(v) -> Node.Comment(v)
  }
}
fn pub clone -> Node

Creates a clone of self.

fmt

Show source code
Hide source code
fn pub fmt(formatter: mut Formatter) {
  match self {
    case Block(tag, nodes) -> {
      formatter.tuple('Block').field(tag).field(nodes).finish
    }
    case Span(tag, nodes) -> {
      formatter.tuple('Span').field(tag).field(nodes).finish
    }
    case Quote(nodes) -> formatter.tuple('Quote').field(nodes).finish
    case Emphasis(nodes) -> formatter.tuple('Emphasis').field(nodes).finish
    case Paragraph(nodes) -> formatter.tuple('Paragraph').field(nodes).finish
    case Strong(nodes) -> formatter.tuple('Strong').field(nodes).finish
    case CodeSpan(nodes) -> formatter.tuple('CodeSpan').field(nodes).finish
    case CodeBlock(info, nodes) -> {
      formatter.tuple('CodeBlock').field(info).field(nodes).finish
    }
    case Text(v) -> formatter.tuple('Text').field(v).finish
    case AutoLink(v) -> formatter.tuple('AutoLink').field(v).finish
    case Link(url, nodes) -> {
      formatter.tuple('Link').field(url).field(nodes).finish
    }
    case Image(url, text) -> {
      formatter.tuple('Image').field(url).field(text).finish
    }
    case Heading(level, nodes) -> {
      formatter.tuple('Heading').field(level).field(nodes).finish
    }
    case Footnote(name) -> formatter.tuple('Footnote').field(name).finish
    case UnorderedList(n) -> formatter.tuple('UnorderedList').field(n).finish
    case OrderedList(n) -> formatter.tuple('OrderedList').field(n).finish
    case ListItem(nodes) -> formatter.tuple('ListItem').field(nodes).finish
    case ThematicBreak -> formatter.tuple('ThematicBreak').finish
    case Superscript(n) -> formatter.tuple('Superscript').field(n).finish
    case Subscript(n) -> formatter.tuple('Subscript').field(n).finish
    case Table(head, body, foot) -> {
      formatter.tuple('Table').field(head).field(body).field(foot).finish
    }
    case LineBreak -> formatter.tuple('LineBreak').finish
    case Comment(t) -> formatter.tuple('Comment').field(t).finish
  }
}
fn pub fmt(formatter: mut Formatter)

Formats self in a human-readable format for debugging purposes.

Implemented traits

std.clone.

Clone

impl Clone[Node] for Node
std.cmp.

Equal

impl Equal[ref Node] for Node
std.fmt.

Format

impl Format for Node