1
---
2
title: { TITLE }
3
published: { DATE }
4
description: { DESCRIPTION }
5
image: { COVER_IMAGE_PATH }
6
tags: { TAGS }
7
category: { CATEGORY }
8
location: { LOCATION }
9
draft: { BOOLEAN }
10
---

1
---
2
title: "Title"
3
excerpt: "Display on the card"
4
date: 1970-01-01
5
category: "essays"
6
tags: ["apache", "cncf"]
7
author: "Jysve"
8
thumbnail: ./cover.webp
9
thumbnailAlt: "Comments on the cover."
10
featured: false
11
---

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

1
// This is a code block with syntax highlighting
2
fn main() -> Result<(), Box<dyn std::error::Error>> {
3
    let users = vec![
4
        User::new(1, "Alice".to_string()),
5
        User::new(2, "Bob".to_string()),
6
    ];
7

8
    let user_map = Arc::new(process_users(users));
9
    println!("Processed users: {:?}", user_map);
10
    Ok(())
11
}

1
// Code block without syntax highlighting
2
println!("Hello, world!");

1
::github{repo="apache/iggy"}
2
::github{repo="apache/opendal"}

1
:::hyperlink{href="{target_uri}" title="{title}" avatar="path/to/avatar" description="{say_something}"}
2
:::

1
:::note
2
Highlights information that users should take into account, even when skimming.
3
:::
4

5
:::tip[Custom Title]
6
This is a tip with a custom title.
7
:::

1
> [!NOTE]
2
> The GitHub syntax is also supported.
3

4
> [!TIP]
5
> The GitHub syntax is also supported.

1
The content :spoiler[is hidden **ayyy**]!

1
---
2
title: Draft Example
3
published: 2020-08-27T17:00:41Z
4
tags: [Markdown, Blogging, Demo]
5
category: Examples
6
draft: false
7
---

1
let numbers = vec![1, 2, 3, 4, 5];
2
let doubled: Vec<i32> = numbers
3
    .iter()
4
    .map(|&x| x * 2)
5
    .filter(|&x| x > 4)
6
    .collect();
7
println!("Doubled numbers: {:?}", doubled);

1
rustc main.rs

1
// Line 1 - targeted by line number
2
fn main() {
3
    let x = 42;
4
    // Line 4 - targeted by line number
5
    println!("x = {}", x);
6

7
    // Line 7 - targeted by range "7-8"
8
    // Line 8 - targeted by range "7-8"
9
    let y = x * 2;
10
}

1
pub fn new_function() -> Result<String, Error> {
2
this fn old_function() -> String {
3
   Ok("this is a regular line".to_string())
4
    Ok("this line will be marked as inserted".to_string())
5
}
6
this line will be marked as deleted

1
--- a/src/main.rs
2
+++ b/src/main.rs
3
@@ -1,3 +1,4 @@
4
+use std::collections::HashMap;
5
 fn main() {
6
-    println!("Hello, world!");
7
+    let mut map = HashMap::new();
8
+    map.insert("key", "value");
9
 }

1
fn this_is_rust() {
2
  // This entire block gets highlighted as Rust,
3
  // and we can still add diff markers to it!
4
  println!("Old code to be removed");
5
  println!("New and shiny code!");
6
}

1
fn demo() -> String {
2
    // Mark any given text inside lines
3
    "Multiple matches of the given text are supported".to_string()
4
}

1
println!("The words yes and yep will be marked.");

1
std::fs::write("/home/test.txt", "Test")?;

1
fn demo() -> bool {
2
    println!("These are inserted and deleted marker types");
3
    // The return statement uses the default marker type
4
    true
5
}

1
// Example with wrap
2
fn get_long_string() -> String {
3
    "This is a very long string that will most probably not fit into the available space unless the container is extremely wide".to_string()
4
}

1
// Example with wrap=false
2
fn get_long_string() -> String {
3
    "This is a very long string that will most probably not fit into the available space unless the container is extremely wide".to_string()
4
}

1
// Example with preserveIndent (enabled by default)
2
fn get_long_string() -> String {
3
    "This is a very long string that will most probably not fit into the available space unless the container is extremely wide".to_string()
4
}

1
// Example with preserveIndent=false
2
fn get_long_string() -> String {
3
    "This is a very long string that will most probably not fit into the available space unless the container is extremely wide".to_string()
4
}

5 collapsed lines
1
// All this boilerplate setup code will be collapsed
2
use std::sync::{Arc, Mutex};
3
use tokio::runtime::Runtime;
4

5
let runtime = Arc::new(Mutex::new(Runtime::new()?));
6
let engine = Engine::new(runtime.clone());
7

8
// This part of the code will be visible by default
9
engine.do_something(1, 2, 3, calc_fn)?;
10

11
fn calc_fn() -> i32 {
3 collapsed lines
12
    // You can have multiple collapsed sections
13
    let a = 1;
14
    let b = 2;
15
    let c = a + b;
16

17
    // This will remain visible
18
    println!("Calculation result: {} + {} = {}", a, b, c);
19
    c
20
}
4 collapsed lines
21

22
// All this code until the end of the block will be collapsed again
23
engine.close_connection()?;
24
engine.free_memory();
25
engine.shutdown(ShutdownReason::EndOfExample)?;

1
// This code block will show line numbers
2
use std::collections::BTreeMap;
3

4
let mut scores = BTreeMap::new();
5
scores.insert("Alice", 95);
6
scores.insert("Bob", 87);
7
println!("Total players: {}", scores.len());

// Line numbers are disabled for this block
println!("Hello?");
println!("Sorry, do you know what line I am on?");

5
println!("Greetings from line 5!");
6
println!("I am on line 6");