如何为Rust泛型函数针对特定类型自定义行为？解决API解析报错

我想创建一个泛型函数，用来查询API并可选地将输出解析为JSON。但遇到一个问题：当泛型函数的返回类型为unit类型()时，会调用serde_json::from_str::<()>("")，而这个调用会返回错误。

以下是最小复现示例：

use reqwest::blocking::Client; // 0.11.18
use anyhow::Result; // 1.0.71
use url::Url; // 2.4.0
use serde_json::from_str; // 1.0.102
use serde::Deserialize; // 1.0.171

fn get<T: for<'a> serde::Deserialize<'a>>(client: &Client, url: Url) -> Result<T> {
    let response = client.get(url)
        .send()?
        .error_for_status()?;
    let text = response.text()?;
    let result = from_str::<T>(&text)?;
    Ok(result)
}

#[derive(Debug, Deserialize)]
struct Person {
    name: String,
    height: String,
}

#[derive(Debug, Deserialize)]
struct Planet {
    name: String,
    climate: String,
}

fn main() -> Result<()> {
    let client = Client::new();

    // 查询Person类型数据
    let luke = get::<Person>(&client, Url::parse("https://swapi.dev/api/people/1/")?)?;
    println!("Luke: {:?}", luke);

    // 查询Planet类型数据
    let tatooine = get::<Planet>(&client, Url::parse("https://swapi.dev/api/planets/1/")?)?;
    println!("Tatooine: {:?}", tatooine);

    // 示例：发起不需要返回结果的请求（实际场景多为POST/PUT等）
    get(&client, Url::parse("https://swapi.dev/api/vehicles/4/")?)?; // <- 此处报错
    Ok(())
}

简单的解决办法是单独写一个get_no_result函数跳过解析，但C++里可以用模板特化，Rust不支持这种方式，想问Rust里最符合风格的解决方案是什么？

Rust不支持函数模板特化，但可以通过自定义trait实现ad-hoc多态，这是最符合Rust设计理念的方式。核心思路是为不同的返回类型定义不同的响应处理逻辑，既保持泛型函数的统一性，又能针对()做特殊处理。

方法一：自定义响应处理Trait #

定义一个trait ResponseHandler，为需要解析JSON的类型和()分别实现不同的处理逻辑：

use reqwest::blocking::Client;
use anyhow::Result;
use url::Url;
use serde_json::from_str;
use serde::Deserialize;

// 自定义Trait，定义响应处理逻辑
trait ResponseHandler {
    fn handle_response(response: reqwest::blocking::Response) -> Result<Self>
    where
        Self: Sized;
}

// 为所有可反序列化的类型实现默认处理逻辑：解析JSON
impl<T: for<'a> Deserialize<'a>> ResponseHandler for T {
    fn handle_response(response: reqwest::blocking::Response) -> Result<Self> {
        let text = response.text()?;
        let result = from_str::<T>(&text)?;
        Ok(result)
    }
}

// 为unit类型()实现特殊处理逻辑：直接忽略响应内容
impl ResponseHandler for () {
    fn handle_response(response: reqwest::blocking::Response) -> Result<Self> {
        // 读取响应内容并丢弃（确保连接正常关闭，避免资源泄漏）
        let _ = response.text()?;
        Ok(())
    }
}

// 泛型函数使用自定义Trait约束
fn get<T: ResponseHandler>(client: &Client, url: Url) -> Result<T> {
    let response = client.get(url)
        .send()?
        .error_for_status()?;
    T::handle_response(response)
}

// 以下是原示例中的结构体和main函数，无需修改
#[derive(Debug, Deserialize)]
struct Person {
    name: String,
    height: String,
}

#[derive(Debug, Deserialize)]
struct Planet {
    name: String,
    climate: String,
}

fn main() -> Result<()> {
    let client = Client::new();

    let luke = get::<Person>(&client, Url::parse("https://swapi.dev/api/people/1/")?)?;
    println!("Luke: {:?}", luke);

    let tatooine = get::<Planet>(&client, Url::parse("https://swapi.dev/api/planets/1/")?)?;
    println!("Tatooine: {:?}", tatooine);

    // 现在调用get::<()>()不会报错
    get(&client, Url::parse("https://swapi.dev/api/vehicles/4/")?)?;
    Ok(())
}

这种方式的优势在于：

• 保持了单一入口函数get，无需拆分多个函数
• 扩展性强：后续如果需要为其他类型添加特殊处理，只需新增ResponseHandler的实现即可
• 符合Rust的trait-based多态设计理念

方法二：重载函数（利用返回类型推导） #

Rust支持根据返回类型自动选择不同的函数实现，我们可以为()单独写一个get函数：

use reqwest::blocking::Client;
use anyhow::Result;
use url::Url;
use serde_json::from_str;
use serde::Deserialize;

// 通用版本：解析JSON
fn get<T: for<'a> Deserialize<'a>>(client: &Client, url: Url) -> Result<T> {
    let response = client.get(url)
        .send()?
        .error_for_status()?;
    let text = response.text()?;
    let result = from_str::<T>(&text)?;
    Ok(result)
}

// 针对()的特殊版本
fn get(client: &Client, url: Url) -> Result<()> {
    let response = client.get(url)
        .send()?
        .error_for_status()?;
    let _ = response.text()?;
    Ok(())
}

// 调用时无需显式指定类型，编译器会自动推导
fn main() -> Result<()> {
    let client = Client::new();
    let luke: Person = get(&client, Url::parse("https://swapi.dev/api/people/1/")?)?;
    let tatooine: Planet = get(&client, Url::parse("https://swapi.dev/api/planets/1/")?)?;
    get(&client, Url::parse("https://swapi.dev/api/vehicles/4/")?)?; // 自动调用()版本
    Ok(())
}

这种方式简洁直观，但缺点是如果后续需要添加更多特殊类型，就得不断新增同名函数，扩展性不如trait方案。

内容的提问来源于stack exchange，提问作者Romain Deterre