创建一个可以添加 i64、f64 或 i64 和 f64 混合的 Rust 函数

Question

我想编写一个

add

函数，可以将

i64

或

f64

作为两个参数的输入。

我能够想出以下内容：

use std::ops::Add;

fn add<T: Add<Output = T>>(a: T, b: T) -> T{
    a + b
}

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30
    println!("{:?}", add(c, d)); // Outputs: 31.0
}

是否可以修改此功能，以便可以拥有：

• 一个参数是

  i64

• 另一个参数是

  f64

如果其中一个参数是

f64

，我们进行强制转换，并返回

f64

。

的类型 的类型

a	b	回来了 type
i64	i64	i64
i64	f64	f64
f64	i64	f64
f64	f64	f64

主函数将有以下输出：

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30    | i64 + i64 -> i64
    println!("{:?}", add(a, c)); // Outputs: 20.5  | i64 + f64 -> f64
    println!("{:?}", add(c, a)); // Outputs: 20.5  | f64 + i64 -> f64
    println!("{:?}", add(c, d)); // Outputs: 30.0  | f64 + f64 -> f64
}

Answer 1

您可以使用特征来做到这一点。该特征可以与内置

Add

特征相同，但由于孤儿规则，您不能使用

Add

特征本身。这是一个示例实现：

pub trait MyAdd<RHS> {
    type Output;

    fn add(self, b: RHS) -> Self::Output;
}

impl MyAdd<i64> for i64 {
    type Output = i64;

    fn add(self, b: i64) -> Self::Output {
        self + b
    }
}

impl MyAdd<f64> for f64 {
    type Output = f64;

    fn add(self, b: f64) -> Self::Output {
        self + b
    }
}

impl MyAdd<i64> for f64 {
    type Output = f64;

    fn add(self, b: i64) -> Self::Output {
        self + b as f64
    }
}

impl MyAdd<f64> for i64 {
    type Output = f64;

    fn add(self, b: f64) -> Self::Output {
        self as f64 + b
    }
}

pub fn add<T, U>(a: T, b: U) -> T::Output
where
    T: MyAdd<U>,
{
    a.add(b)
}

游乐场