🎨 chore(tarot_ai): tidy tarot_ai.rs

Author: Lhcfl

src/mods/tarot_ai.rs

@@ -11,6 +11,7 @@ use teloxide_core::types::*;
 
 use crate::assets::tarot;
 use crate::linquebot::*;
+use crate::utils::partition_results;
 use crate::utils::telegram::prelude::WarnOnError;
 use crate::Consumption;
 
@@ -46,40 +47,25 @@ struct AiResponseChoice {
     message: AiMessage,
 }
 
-async fn get_env_var(key: &str) -> anyhow::Result<String> {
-    match env::var(key) {
-        Ok(val) => Ok(val),
-        Err(err) => {
-            warn!("get-env-var-error, please specify {key}:\n{err}");
-            Err(err.into())
-        }
-    }
+fn get_env_var(key: &str) -> Result<String, String> {
+    env::var(key).map_err(|err| format!("{key}: {err}"))
 }
 
 async fn get_tarot(question: &str) -> anyhow::Result<String> {
     let client = reqwest::Client::new();
 
     let tarots = tarot::n_random_majors(3)
         .into_iter()
-        .map(|t| {
-            format!(
-                "序号：{}，是否反转：{}",
-                t.id,
-                if t.is_reverse { "是" } else { "否" }
-            )
-        })
+        .map(|t| t.to_string())
         .collect::<Vec<_>>()
         .join("\n");
 
-    let url = get_env_var("AI_API_URL").await;
-    let token = get_env_var("AI_API_TOKEN").await;
-    let model = get_env_var("AI_API_MODEL").await;
-
-    // 这样写是为了让一个环境变量未找到时，也尝试查找剩余的几个。
-    // 让报错更全面，避免反复重启看报错。
-    let url = url?;
-    let token = token?;
-    let model = model?;
+    let [url, token, model] = partition_results([
+        get_env_var("AI_API_URL"),
+        get_env_var("AI_API_TOKEN"),
+        get_env_var("AI_API_MODEL"),
+    ])
+    .map_err(|errs| anyhow::anyhow!(errs.join("\n")))?;
 
     let prompt = match env::var("TAROT_AI_PROMPT") {
         Ok(val) => val,

src/utils/mod.rs

@@ -74,6 +74,23 @@ pub fn split_args<const N: usize>(src: &str) -> [&str; N] {
     res
 }
 
+pub fn partition_results<const N: usize, T, E>(input: [Result<T, E>; N]) -> Result<[T; N], Vec<E>> {
+    let mut oks: [Option<T>; N] = [(); N].map(|_| None);
+    let mut errs: Vec<E> = Vec::new();
+    for (i, item) in input.into_iter().enumerate() {
+        match item {
+            Ok(v) => oks[i] = Some(v),
+            Err(e) => errs.push(e),
+        }
+    }
+    if errs.is_empty() {
+        // SAFETY: we have ensured all elements in `oks` are `Some`
+        Ok(oks.map(|o| o.unwrap()))
+    } else {
+        Err(errs)
+    }
+}
+
 pub mod telegram {
     pub mod prelude {
         use std::future::Future;