Enum teloxide::types::ParseMode

pub enum ParseMode {
    MarkdownV2,
    Html,
    Markdown,
}

Formatting options.

The Bot API supports basic formatting for messages. You can use bold, italic, underlined, strikethrough, and spoiler text, as well as inline links and pre-formatted code in your bots’ messages. Telegram clients will render them accordingly. You can use either markdown-style or HTML-style formatting.

Note that Telegram clients will display an alert to the user before opening an inline link (‘Open this link?’ together with the full URL).

Message entities can be nested, providing following restrictions are met:

• If two entities have common characters then one of them is fully contained inside another.
• bold, italic, underline, strikethrough, and spoiler entities can contain and can be part of any other entities, except pre and code.
• All other entities can’t contain each other.

Links tg://user?id=<user_id> can be used to mention a user by their ID without using a username. Please note:

• These links will work only if they are used inside an inline link. For example, they will not work, when used in an inline keyboard button or in a message text.
• These mentions are only guaranteed to work if the user has contacted the bot in the past, has sent a callback query to the bot via inline button or is a member in the group where he was mentioned.

MarkdownV2 style

To use this mode, pass MarkdownV2 in the parse_mode field. Use the following syntax in your message:

*bold \*text*
_italic \*text_
__underline__
~strikethrough~
||spoiler||
*bold _italic bold ~italic bold strikethrough ||italic bold strikethrough spoiler||~ __underline italic bold___ bold*
[inline URL](http://www.example.com/)
[inline mention of a user](tg://user?id=123456789)
`inline fixed-width code`
```
pre-formatted fixed-width code block
```
```rust
pre-formatted fixed-width code block written in the Rust programming language
```

Please note:

• Any character between 1 and 126 inclusively can be escaped anywhere with a preceding ’' character, in which case it is treated as an ordinary character and not a part of the markup.
• Inside pre and code entities, all ’`‘ and ’\‘ characters must be escaped with a preceding ’' character.
• Inside (...) part of inline link definition, all ’)‘ and ’\‘ must be escaped with a preceding ’' character.
• In all other places characters ’_‘, ’*‘, ’[‘, ’]‘, ’(‘, ’)‘, ’~‘, ’`‘, ’>‘, ’#‘, ’+‘, ’+‘, ’-‘, ’|‘, ’{‘, ’}‘, ’.‘, ’!‘ must be escaped with the preceding character ’'.
• In case of ambiguity between italic and underline entities ‘__’ is always greadily treated from left to right as beginning or end of underline entity, so instead of ___italic underline___ use ___italic underline_\r__, where \r is a character with code 13, which will be ignored.

HTML style

To use this mode, pass Html in the parse_mode field. The following tags are currently supported:

<b>bold</b>, <strong>bold</strong>
<i>italic</i>, <em>italic</em>
<u>underline</u>, <ins>underline</ins>
<s>strikethrough</s>, <strike>strikethrough</strike>, <del>strikethrough</del>
<span class="tg-spoiler">spoiler</span>, <tg-spoiler>spoiler</tg-spoiler>
<b>bold <i>italic bold <s>italic bold strikethrough <span class="tg-spoiler">italic bold strikethrough spoiler</span></s> <u>underline italic bold</u></i> bold</b>
<a href="http://www.example.com/">inline URL</a>
<a href="tg://user?id=123456789">inline mention of a user</a>
<code>inline fixed-width code</code>
<pre>pre-formatted fixed-width code block</pre>
<pre><code class="language-rust">pre-formatted fixed-width code block written in the Rust programming language</code></pre>

Please note:

• Only the tags mentioned above are currently supported.
• All <, > and & symbols that are not a part of a tag or an HTML entity must be replaced with the corresponding HTML entities (< with <, > with > and & with &).
• All numerical HTML entities are supported.
• The API currently supports only the following named HTML entities: <, >, & and ".
• Use nested pre and code tags, to define programming language for pre entity.
• Programming language can’t be specified for standalone code tags.

Markdown style

This is a legacy mode, retained for backward compatibility. To use this mode, pass Markdown in the parse_mode field. Use the following syntax in your message:

*bold text*
_italic text_
[inline URL](http://www.example.com/)
[inline mention of a user](tg://user?id=123456789)
`inline fixed-width code`
```
pre-formatted fixed-width code block
```
```rust
pre-formatted fixed-width code block written in the Rust programming language
```

Please note:

• Entities must not be nested, use parse mode MarkdownV2 instead.
• There is no way to specify underline and strikethrough entities, use parse mode MarkdownV2 instead.
• To escape characters ’_‘, ’*‘, ’`‘, ’[‘ outside of an entity, prepend the characters ’' before them.
• Escaping inside entities is not allowed, so entity must be closed first and reopened again: use _snake_\__case_ for italic snake_case and *2*\**2=4* for bold 2*2=4.

Variants

MarkdownV2

Html

Markdown

👎Deprecated: This is a legacy mode, retained for backward compatibility. Use MarkdownV2 instead.

Trait Implementations

impl Clone for ParseMode

fn clone(&self) -> ParseMode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParseMode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ParseMode

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ParseMode, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for ParseMode

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ParseMode, <ParseMode as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ParseMode

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ParseMode> for ParseMode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ParseMode

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

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for ParseMode

type Error = ()

The type returned in the event of a conversion error.

fn try_from(
    value: &str
) -> Result<ParseMode, <ParseMode as TryFrom<&str>>::Error>

Performs the conversion.

impl TryFrom<String> for ParseMode

type Error = ()

The type returned in the event of a conversion error.

fn try_from(
    value: String
) -> Result<ParseMode, <ParseMode as TryFrom<String>>::Error>

Performs the conversion.

impl Copy for ParseMode

impl Eq for ParseMode

impl StructuralEq for ParseMode

impl StructuralPartialEq for ParseMode