Как реализовать дженерики в ржавчине, когда параметр generi c имеет несколько типов данных?

Question

Я новичок ie в Rust.

Я пытаюсь реализовать функцию generi c в ржавчине, но у меня возникают проблемы с этим. Я пробовал так много примеров из Google, чтобы найти решение, но ничего не помогло. Пожалуйста, помогите мне.

Здесь, в приведенном ниже коде, я хочу реализовать функцию add для Point, которая может принимать либо i32, либо другой Point.

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point.add::<i32>(&1);
    point.add::<Point>(&point);
}

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    pub fn new(x: i32, y: i32) -> Point {
        Point {x, y}
    }

    /**
    Pseudocode as i don't know how to write this in rust
    pub fn add<T: Sized || Point>(&mut self, value: &T) {
            if (T is i32) {
                self.x += = value;
                self.y += value;
            } else (T is Point) {
                self.x += value.x;
                self.y += value.y;
            }
        
    }
    */
}

Answer 1

Вы можете сделать это с помощью трейта. Поскольку Point равно Copy, также нет необходимости использовать ссылки:

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

trait AddToPoint<T> {
    fn add(&mut self, value: T);
}

impl AddToPoint<i32> for Point {
    fn add(&mut self, value: i32) {
        self.x += value;
        self.y += value;
    }
}

impl AddToPoint<Point> for Point {
    fn add(&mut self, value: Point) {
        self.x += value.x;
        self.y += value.y;
    }
}

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point.add(1);
    point.add(point);
}

Другая возможность - использовать перегрузку оператора, реализовав трейт std::ops::AddAssign. Затем вы можете использовать оператор += для добавления значений к точкам:

use std::ops::AddAssign;

#[derive(Copy, Clone)]
struct Point {
    pub x: i32,
    pub y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

impl AddAssign<i32> for Point {
    fn add_assign(&mut self, value: i32) {
        self.x += value;
        self.y += value;
    }
}

impl AddAssign<Point> for Point {
    fn add_assign(&mut self, value: Point) {
        self.x += value.x;
        self.y += value.y;
    }
}

fn main() {
    println!("Hello world!");
    let mut point = Point::new(1,1);
    point += 1;
    point += point;
}

Answer 2

Вот пример параллельной обычной функции и c функции generi. struct Val {val: f64,}

struct GenVal<T> {
    gen_val: T,
}

// impl of Val
impl Val {
    fn value(&self) -> &f64 {
        &self.val
    }
}

// impl of GenVal for a generic type `T`
impl<T> GenVal<T> {
    fn value(&self) -> &T {
        &self.gen_val
    }
}

fn main() {
    let x = Val { val: 3.0 };
    let y = GenVal { gen_val: 3i32 };

    println!("{}, {}", x.value(), y.value());
}