result-panic/result #241

2022-05-16T08:31:52Z

giscus[bot]
bot May 16, 2022

result-panic/result

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/result-panic/result.html

0xlwoe21k · 2022-05-16T08:31:54Z

0xlwoe21k
May 16, 2022 — with giscus

第一题的题目和答案对不上

1 reply

0xlwoe21k May 16, 2022 — with giscus

感觉是我理解错了，我以为只能填写横线，不能改动其它地方

Zazaye2 · 2022-07-19T06:10:14Z

Zazaye2
Jul 19, 2022 — with giscus

有大佬解惑吗？这里为什么不能用两个map，前面必须用and_then会报错。

// 提示：使用 and_then 和 map
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
n1_str.parse::().map(|x|n2_str.parse::().map(|y|{x*y}))
}

6 replies

sujiacong Jul 31, 2022 — with giscus

原因是map使用的闭包函数的返回类型不是Result，第二个map不适合放到第一个map的闭包函数里。

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where
F: FnOnce(T) -> Result<U, E>,

pub fn map<U, F>(self, op: F) -> Result<U, E>
where
F: FnOnce(T) -> U,

sperains Sep 19, 2022 — with giscus

fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {

let n1 = n1_str.parse::<i32>();

let n2 = n2_str.parse::<i32>();

n1.and_then(|x| n2.map(|y| y * x))

}

sperains Sep 19, 2022 — with giscus

本题中函数multiply返回的类型是Result<i32, ParseIntError>,
如果用两个map那么返回值就变成了Result< Result<i32, ParseIntError>, ParseIntError>了.

嵌套的map 会返回一个 Result<i32, ParseIntError>, 此时会变成外层的map返回的Result的Ok值

sperains Sep 20, 2022 — with giscus

pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E> {
match self {
Ok(t) => Ok(op(t)),
Err(e) => Err(e),
}
}

pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E> {
match self {
Ok(t) => op(t),
Err(e) => Err(e),
}
}

FortuneOreo Dec 28, 2024 — with giscus

因为map要求的闭包必须返回的是一个T类型，在这里是返回i32类型，但map本身又是返回的Result类型；所以两个map嵌套用的话，内嵌的map的返回类型没法满足外层map对所需闭包的要求。

hedongyouxia · 2022-10-21T03:07:08Z

hedongyouxia
Oct 21, 2022 — with giscus

5题另一种实现：

Ok(n1_str.parse::<i32>()? * n2_str.parse::<i32>()?)

0 replies

hhrreedd · 2022-10-27T09:33:53Z

hhrreedd
Oct 27, 2022 — with giscus

第5题：我是这么写的，这块东西还没讲到
type Res = Result<T, ParseIntError>;

0 replies

mattwhatsup · 2022-11-21T05:00:41Z

mattwhatsup
Nov 21, 2022 — with giscus

main里的return问题
原题如果改成用特征对象就会报错

use std::num::ParseIntError;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let number_str = "10";
    let number = match number_str.parse::<i32>() {
        Ok(number)  => number,
        Err(e) => return Err(e),
    };
    println!("{}", number);
    Ok(())
}

用?就成功，这是为什么呢？不是说?是个宏，其实也是return了Err(e)的吗？

use std::num::ParseIntError;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let number_str = "10";
    let number = number_str.parse::<i32>()?;
    println!("{}", number);
    Ok(())
}

1 reply

mattwhatsup Nov 26, 2022 — with giscus

Ok 犯蠢了

Err(e) => return Err(Box::new(e)), 就可以了

Bruce012356 · 2023-01-12T07:25:04Z

Bruce012356
Jan 12, 2023 — with giscus

mark

0 replies

lihongtao1024 · 2023-04-20T03:59:54Z

lihongtao1024
Apr 20, 2023 — with giscus

第一题：

// 填空并修复错误
use std::num::ParseIntError;

fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    let n1 = n1_str.parse::<i32>();
    let n2 = n2_str.parse::<i32>();
    Ok(n1.unwrap() * n2.unwrap())
}

fn main() {
    let result = multiply("10", "2");
    assert_eq!(result, Ok(20));

    let result = multiply("4", "2");
    assert_eq!(result.unwrap(), 8);

    println!("Success!")
}

第二题：

use std::num::ParseIntError;

// 使用 `?` 来实现 multiply
// 不要使用 unwrap !
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    Ok(n1_str.parse::<i32>()? * n2_str.parse::<i32>()?)
}

fn main() {
    assert_eq!(multiply("3", "4").unwrap(), 12);
    println!("Success!")
}

第三题：

use std::fs::File;
use std::io::{self, Read};

fn read_file1() -> Result<String, io::Error> {
    let f = File::open("hello.txt");
    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();
    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

// 填空
// 不要修改其它代码
fn read_file2() -> Result<String, io::Error> {
    let mut s = String::new();

    File::open("hello.txt")?.read_to_string(&mut s)?;

    Ok(s)
}

fn main() {
    assert_eq!(read_file1().unwrap_err().to_string(), read_file2().unwrap_err().to_string());
    println!("Success!")
}

第四题：

use std::num::ParseIntError;

// 使用两种方式填空: map, and then
fn add_two1(n_str: &str) -> Result<i32, ParseIntError> {
   n_str.parse::<i32>().map(|n| n + 2)
}

fn add_two2(n_str: &str) -> Result<i32, ParseIntError> {
    n_str.parse::<i32>().and_then(|n| Ok(n + 2))
 }

fn main() {
    assert_eq!(add_two1("4").unwrap(), 6);
    assert_eq!(add_two2("4").unwrap(), 6);

    println!("Success!")
}

第五题：

use std::num::ParseIntError;

// 使用 Result 重写后，我们使用模式匹配的方式来处理，而无需使用 `unwrap`
// 但是这种写法实在过于啰嗦..
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    match n1_str.parse::<i32>() {
        Ok(n1)  => {
            match n2_str.parse::<i32>() {
                Ok(n2)  => {
                    Ok(n1 * n2)
                },
                Err(e) => Err(e),
            }
        },
        Err(e) => Err(e),
    }
}

// 重写上面的 `multiply` ，让它尽量简介
// 提示：使用 `and_then` 和 `map`
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    // 实现...
    Ok(n1_str.parse::<i32>()? * n2_str.parse::<i32>()?)
}

fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let twenty = multiply1("10", "2");
    print(twenty);

    // 下面的调用会提供更有帮助的错误信息
    let tt = multiply("t", "2");
    print(tt);

    println!("Success!")
}

第六题：

use std::num::ParseIntError;

// 填空
type Res<T> = Result<T, ParseIntError>;

// 使用上面的别名来引用原来的 `Result` 类型
fn multiply(first_number_str: &str, second_number_str: &str) -> Res<i32> {
    first_number_str.parse::<i32>().and_then(|first_number| {
        second_number_str.parse::<i32>().map(|second_number| first_number * second_number)
    })
}

// 同样, 这里也使用了类型别名来简化代码
fn print(result: Res<i32>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    print(multiply("10", "2"));
    print(multiply("t", "2"));

    println!("Success!")
}

1 reply

lihongtao1024 Apr 20, 2023 — with giscus

第五题要求使用and_then和map，修改如下：

use std::num::ParseIntError;

// 使用 Result 重写后，我们使用模式匹配的方式来处理，而无需使用 `unwrap`
// 但是这种写法实在过于啰嗦..
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    match n1_str.parse::<i32>() {
        Ok(n1)  => {
            match n2_str.parse::<i32>() {
                Ok(n2)  => {
                    Ok(n1 * n2)
                },
                Err(e) => Err(e),
            }
        },
        Err(e) => Err(e),
    }
}

// 重写上面的 `multiply` ，让它尽量简介
// 提示：使用 `and_then` 和 `map`
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    // 实现...
    n1_str.parse::<i32>().and_then(|n1| {
        n2_str.parse::<i32>().map(|n2| n1 * n2)
    })
}

fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let twenty = multiply1("10", "2");
    print(twenty);

    // 下面的调用会提供更有帮助的错误信息
    let tt = multiply("t", "2");
    print(tt);

    println!("Success!")
}

XU0618 · 2023-05-06T15:39:06Z

XU0618
May 6, 2023 — with giscus

lala~

0 replies

Ghy0202 · 2023-07-19T08:23:45Z

Ghy0202
Jul 19, 2023 — with giscus

前3题，关注Result和?
1、Result<T,E>返回需要声明一下具体的返回类型

// 填空并修复错误
use std::num::ParseIntError;

fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    let n1 = n1_str.parse::<i32>();
    let n2 = n2_str.parse::<i32>();
    Ok(n1.unwrap() * n2.unwrap())
}

fn main() {
    let result  = multiply("10", "2");
    assert_eq!(result, Ok(20));

    let result = multiply("4", "2");
    assert_eq!(result.unwrap(), 8);

    println!("Success!")
}

2、?的使用

use std::num::ParseIntError;

// 使用 `?` 来实现 multiply
// 不要使用 unwrap !
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError>{
    let n1 = n1_str.parse::<i32>();
    let n2 = n2_str.parse::<i32>();
    Ok(n1?*n2?)
}

fn main() {
    assert_eq!(multiply("3", "4").unwrap(), 12);
    println!("Success!")
}

3、?的链式使用

use std::fs::File;
use std::io::{self, Read};

fn read_file1() -> Result<String, io::Error> {
    let f = File::open("hello.txt");
    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();
    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

// 填空
// 不要修改其它代码
fn read_file2() -> Result<String, io::Error> {
    let mut s = String::new();

    File::open("hello.txt")?.read_to_string(&mut s)?;

    Ok(s)
}

fn main() {
    assert_eq!(read_file1().unwrap_err().to_string(), read_file2().unwrap_err().to_string());
    println!("Success!")
}

0 replies

tjw123hh · 2023-08-06T14:10:15Z

tjw123hh
Aug 6, 2023 — with giscus

use std::num::ParseIntError;

// 使用 `?` 来实现 multiply
// 不要使用 unwrap !
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    Ok(n1_str.parse::<i32>()? * n2_str.parse::<i32>()?)
}

fn main() {
    assert_eq!(multiply("3", "4").unwrap(), 12);
    println!("Success!")
}

0 replies

chenhai998 · 2023-08-15T15:08:08Z

chenhai998
Aug 15, 2023 — with giscus

如果我的函数中可能会出现两个以上不同类型的Error,怎么使用Result啊

1 reply

Icemans007 May 16, 2024 — with giscus

文章有讲呀，使用动态对象，Box<dyn std::error::Error> 它可以接受所有类型错误

DaZhou-ECHO · 2023-10-05T10:36:21Z

DaZhou-ECHO
Oct 5, 2023 — with giscus

第五题

let n2=n2_str.parse::<i32>()?;
n1_str.parse::<i32>().map(|x| x*n2)
 
let n2=n2_str.parse::<i32>()?;
n1_str.parse::<i32>().and_then(|x| Ok(x*n2))
 
 let n1=n1_str.parse::<i32>()?;
 let n2=n2_str.parse::<i32>()?;
 Ok(n1*n2)

0 replies

LovingElysia · 2024-04-09T03:53:39Z

LovingElysia
Apr 9, 2024 — with giscus

map 和 and then什么时候讲的闭包参数不是到后面才有吗

0 replies

chuanbei888 · 2024-04-19T09:41:58Z

chuanbei888
Apr 19, 2024 — with giscus

第五题这样写也能通过
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
n1_str.parse::().map(|n1| {
n2_str.parse::().and_then(|n2| Ok(n1*n2))})?
}

1 reply

chuanbei888 Apr 19, 2024 — with giscus

两个map也行
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
n1_str.parse::().map(|n1| {
n2_str.parse::().map(|n2| n1*n2)})?
}

MTDickens · 2024-04-25T00:41:32Z

MTDickens
Apr 25, 2024 — with giscus

如果有人知道 Haskell 的话，Rust 的 map 就是 Haskell 的 fmap，而 and_then 就是 Haskell 的 >>=。

fmap :: Functor f => f a -> (a -> b) -> f b
(>>=) :: Monad m => m a -> (a -> m b) -> m b

对应到 Rust 就是：
fmap[map] :
输入

Result<i32, E>
i32 -> f32
输出
Result<f32, E>

(>>=)[and_then]:
输入

Result<i32, E>
i32 -> Result<f32, E>
输出
Result<f32, E>

0 replies

MTDickens · 2024-04-25T00:52:00Z

MTDickens
Apr 25, 2024 — with giscus

第五题可以用一种更加 Haskell 式（或者 Async/Await 式）的方法来写

use std::num::ParseIntError;
use donotation::m;

// 使用 Result 重写后，我们使用模式匹配的方式来处理，而无需使用 `unwrap`
// 但是这种写法实在过于啰嗦..
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    match n1_str.parse::<i32>() {
        Ok(n1)  => {
            match n2_str.parse::<i32>() {
                Ok(n2)  => {
                    Ok(n1 * n2)
                },
                Err(e) => Err(e),
            }
        },
        Err(e) => Err(e),
    }
}

// 重写上面的 `multiply` ，让它尽量简洁
// 提示：使用 `and_then` 和 `map`
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    m! {
        x <- n1_str.parse::<i32>();
        y <- n2_str.parse::<i32>();
        return x * y;
    }
}

fn print(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    let twenty = multiply1("10", "2");
    print(twenty);

    // 下面的调用会提供更有帮助的错误信息
    let tt = multiply("t", "2");
    print(tt);

    println!("Success!")
}

1 reply

MTDickens Apr 25, 2024 — with giscus

不过作者好像没有 donotation::m 这个包，因此我们只能把 m! 宏的源码复制过来：

macro_rules! m {
  // return
  (return $r:expr ;) => {
    $crate::Lift::lift($r)
  };

  // let-binding
  (let $p:pat = $e:expr ; $($r:tt)*) => {{
    let $p = $e;
    m!($($r)*)
  }};

  // const-bind
  (_ <- $x:expr ; $($r:tt)*) => {
    $x.and_then(move |_| { m!($($r)*) })
  };

  // bind
  ($binding:ident <- $x:expr ; $($r:tt)*) => {
    $x.and_then(move |$binding| { m!($($r)*) })
  };

  // const-bind
  ($e:expr ; $($a:tt)*) => {
    $e.and_then(move |_| m!($($a)*))
  };

  // pure
  ($a:expr) => {
    $a
  }
}

/// Lift a value inside a monad.
pub trait Lift<A> {
  /// Lift a value into a default structure.
  fn lift(a: A) -> Self;
}

impl<A> Lift<A> for Option<A> {
  fn lift(a: A) -> Self {
    Some(a)
  }
}

impl<A, E> Lift<A> for Result<A, E> {
  fn lift(a: A) -> Self {
    Ok(a)
  }
}

用以上源码代替 use donotation::m 即可。

karapy · 2024-04-27T17:38:39Z

karapy
Apr 27, 2024 — with giscus

done!

0 replies

DylanJinx · 2024-06-05T09:29:54Z

DylanJinx
Jun 5, 2024 — with giscus

第五题的四种写法：

// fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
//     // 实现...
//     n1_str.parse::<i32>().map(|n1| n1 * n2_str.parse::<i32>().unwrap())
// }

// fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
//     n1_str.parse::<i32>().map(|n1| {
//         n2_str.parse::<i32>().map(|n2| n2 * n1)
//     })? // 不加？的类型： Result<Result<i32, ParseIntError>, ParseIntError>
// }

// fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
//     n1_str.parse::<i32>().map(|n1| {
//         n2_str.parse::<i32>().and_then(|n2| Ok(n2 * n1))
//     })? // 不加？的类型： Result<Result<i32, ParseIntError>, ParseIntError> 
// }

fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    n1_str.parse::<i32>().and_then(|n1| {
        n2_str.parse::<i32>().map(|n2| n2 * n1)
    }) 
}

0 replies

DylanJinx · 2024-06-05T09:31:54Z

DylanJinx
Jun 5, 2024 — with giscus

done~~~

0 replies

TDAkory · 2024-07-25T12:51:31Z

TDAkory
Jul 25, 2024 — with giscus

mark finished

0 replies

shurgogo · 2024-09-10T13:38:17Z

shurgogo
Sep 10, 2024 — with giscus

第3题不对吧，如果有 hello.txt 文件，在main函数中unwrap_err 不就 panic 了吗？“Success!” 不能

0 replies

ZYKWLJ · 2024-12-18T04:44:28Z

ZYKWLJ
Dec 18, 2024 — with giscus

一个问题，这里的？宏运算，我直接这样返回也是可以的，为啥还需要？运算，有咩有一个好的例子说明传播错误的重要性，以及？在这里面的作用。

fn divide(x: f64, y: f64) -> Result<f64, &'static str> {
    if y == 0.0 {
        Err("除数不能为0")
    } else {
        Ok(x / y)
    }
}

fn calculate(x: f64, y: f64, z: f64) -> Result<f64, &'static str> {
    let result1 = divide(x, y)?;
//在这里下面的两行，我直接返回divide(result1, z)调用结果也是可以的，为什么还需要多此一举？
    let result2=divide(result1, z)?
    result2
}

fn main() {
    let result = calculate(10.0, 2.0, 0.0);
    match result {
        Ok(val) => println!("计算结果: {}", val),
        Err(err) => println!("出错了: {}", err),
    }
}

0 replies

gastrodia · 2025-01-14T08:40:42Z

gastrodia
Jan 14, 2025 — with giscus

第一题

// 填空并修复错误
use std::num::ParseIntError;

fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    let n1 = n1_str.parse::<i32>();
    let n2 = n2_str.parse::<i32>();
    Ok(n1? * n2?)
}

fn main() {
    let result = multiply("10", "2");
    assert_eq!(result, Ok(20));

    let result = multiply("t", "2");
    assert_eq!(result.unwrap_or(8), 8);

    println!("Success!")
}

第二题

fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    let n1 = n1_str.parse::<i32>();
    let n2 = n2_str.parse::<i32>();
    Ok(n1? * n2?)
}

第三题

fn read_file2() -> Result<String, io::Error> {
    let mut s = String::new();

    File::open("hello.txt")?.read_to_string(&mut s)?;

    Ok(s)
}

第四题

fn add_two(n_str: &str) -> Result<i32, ParseIntError> {
    // n_str.parse::<i32>().map(|n| n + 2)
    n_str.parse::<i32>().and_then(|n| Ok(n + 2))
}

第五题

fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
    // 实现1...
    /*let result  = n1_str.parse::<i32>()? * n2_str.parse::<i32>()?;
    Ok(result)*/
    
    // 实现2...
    n1_str.parse::<i32>().and_then(|n1|  n2_str.parse::<i32>().map(|n2|n1 * n2))
}

第六题

type Res<T> = Result<T, ParseIntError>;

0 replies

HenryLunaAdam · 2025-04-06T08:01:05Z

HenryLunaAdam
Apr 6, 2025 — with giscus

except the map& and_then, done

0 replies

result-panic/result #241

giscus[bot] bot May 16, 2022

result-panic/result

Replies: 24 comments · 12 replies

0xlwoe21k May 16, 2022 — with giscus

0xlwoe21k May 16, 2022 — with giscus

Zazaye2 Jul 19, 2022 — with giscus

sujiacong Jul 31, 2022 — with giscus

sperains Sep 19, 2022 — with giscus

sperains Sep 19, 2022 — with giscus

sperains Sep 20, 2022 — with giscus

FortuneOreo Dec 28, 2024 — with giscus

hedongyouxia Oct 21, 2022 — with giscus

hhrreedd Oct 27, 2022 — with giscus

mattwhatsup Nov 21, 2022 — with giscus

mattwhatsup Nov 26, 2022 — with giscus

Bruce012356 Jan 12, 2023 — with giscus

lihongtao1024 Apr 20, 2023 — with giscus

lihongtao1024 Apr 20, 2023 — with giscus

XU0618 May 6, 2023 — with giscus

Ghy0202 Jul 19, 2023 — with giscus

tjw123hh Aug 6, 2023 — with giscus

chenhai998 Aug 15, 2023 — with giscus

Icemans007 May 16, 2024 — with giscus

DaZhou-ECHO Oct 5, 2023 — with giscus

LovingElysia Apr 9, 2024 — with giscus

chuanbei888 Apr 19, 2024 — with giscus

chuanbei888 Apr 19, 2024 — with giscus

MTDickens Apr 25, 2024 — with giscus

MTDickens Apr 25, 2024 — with giscus

MTDickens Apr 25, 2024 — with giscus

karapy Apr 27, 2024 — with giscus

DylanJinx Jun 5, 2024 — with giscus

DylanJinx Jun 5, 2024 — with giscus

TDAkory Jul 25, 2024 — with giscus

shurgogo Sep 10, 2024 — with giscus

ZYKWLJ Dec 18, 2024 — with giscus

gastrodia Jan 14, 2025 — with giscus

HenryLunaAdam Apr 6, 2025 — with giscus

giscus[bot]
bot May 16, 2022

Replies: 24 comments 12 replies

0xlwoe21k
May 16, 2022 — with giscus

Zazaye2
Jul 19, 2022 — with giscus

hedongyouxia
Oct 21, 2022 — with giscus

hhrreedd
Oct 27, 2022 — with giscus

mattwhatsup
Nov 21, 2022 — with giscus

Bruce012356
Jan 12, 2023 — with giscus

lihongtao1024
Apr 20, 2023 — with giscus

XU0618
May 6, 2023 — with giscus

Ghy0202
Jul 19, 2023 — with giscus

tjw123hh
Aug 6, 2023 — with giscus

chenhai998
Aug 15, 2023 — with giscus

DaZhou-ECHO
Oct 5, 2023 — with giscus

LovingElysia
Apr 9, 2024 — with giscus

chuanbei888
Apr 19, 2024 — with giscus

MTDickens
Apr 25, 2024 — with giscus

MTDickens
Apr 25, 2024 — with giscus

karapy
Apr 27, 2024 — with giscus

DylanJinx
Jun 5, 2024 — with giscus

DylanJinx
Jun 5, 2024 — with giscus

TDAkory
Jul 25, 2024 — with giscus

shurgogo
Sep 10, 2024 — with giscus

ZYKWLJ
Dec 18, 2024 — with giscus

gastrodia
Jan 14, 2025 — with giscus

HenryLunaAdam
Apr 6, 2025 — with giscus