Rust 参数可变性

（嗨），我有两个关于rust中的泛型的问题：

1-i试图将一些C++ Boost类似的概念移植到锈蚀（这里是一个2D点的例子）：

#！[特征（相关类型）]
发布特征点2D{
类型值\类型；
fn x（&self）->&：：值类型；
fn y（&self）->&：：值类型；
}
#[导出（显示）]
发布结构点2{
x:T，
y:T，
}
点2的impl Point2D{
类型值_type=T；
#[内联]
fn x（&self）->&T{
&self.x
}
#[内联]
fn y（&self）->&T{
&赛尔夫
}
}
fn main（）{
设mutp=Point2{x:0i32，y:0i32}；
println！（“p={}”，p）；
//*p、 x（）=1i32；//错误：无法分配给`&`-指针的不可变解引用
}

这里我想要的是，当T是可变的时，x（）和y（）返回对可变T的引用，否则返回一个不可变的引用，这可能吗？ 我看到一些关于参数可变性的内部讨论，但我没有找到任何已建立的RFC

2-是否有任何计划将数值参数化（如

模板

）添加到rust中

谢谢

更新：所以我现在唯一的解决方案是：

#![feature(associated_types)]

pub trait Point2D {
    type value_type;
    fn x_as_mut(&mut self) -> &mut <Self as Point2D>::value_type;
    fn y_as_mut(&mut self) -> &mut <Self as Point2D>::value_type;
    fn x_as_ref(&self) -> &<Self as Point2D>::value_type;
    fn y_as_ref(&self) -> &<Self as Point2D>::value_type;
}

#[deriving(Show)]
pub struct Point2<T> {
    x : T,
    y : T,
}

impl<T> Point2D for Point2<T> {
    type value_type = T;

#[inline]
    fn x_as_mut(&mut self) -> &mut T {
        &mut self.x
    }

#[inline]
    fn y_as_mut(&mut self) -> &mut T {
        &mut self.y
    }
#[inline]
    fn x_as_ref(&self) -> &T {
        &self.x
    }

#[inline]
    fn y_as_ref(&self) -> &T {
        &self.y
    }
}

trait Channel {

}

fn main(){
    let mut p1 = Point2{x: 0i32, y : 0i32};

    println!("p1 = {}", p1);

    *p1.x_as_mut() = 1i32;

    println!("p1 = {}", p1);

    let p2 = Point2{x:0u8, y:10u8};

    println!("p2 = {}", p2.y_as_ref());

}

#！[特征（相关类型）]
发布特征点2D{
类型值\类型；
fn x_as_mut（&mut self）->&mut:：value_type；
fn y_as_mut（&mut self）->&mut:：value_type；
fn x_as_ref（&self）->&：：value_type；
fn y_as_ref（&self）->&：：value_type；
}
#[导出（显示）]
发布结构点2{
x:T，
y:T，
}
点2的impl Point2D{
类型值_type=T；
#[内联]
fn x_as_mut（&mut self）->&mut T T{
&mut self.x
}
#[内联]
fn y_as_mut（&mut self）->&mut T T{
&多自我
}
#[内联]
fn x_as_ref（&self）->&T{
&self.x
}
#[内联]
fn y_as_ref（&self）->&T{
&赛尔夫
}
}
特征通道{
}
fn main（）{
设mutp1=Point2{x:0i32，y:0i32}；
println！（“p1={}”，p1）；
*p1.x_as_mut（）=1i32；
println！（“p1={}”，p1）；
设p2=Point2{x:0u8，y:10u8}；
println！（（“p2={}”，p2.y_作为_ref（））；
}

---

有更干净的方法吗？

没有参数可变性。我知道有几个人已经表达了对这方面的强烈愿望，但我还不知道有什么实际计划

---

也没有通用值参数。我相信核心团队肯定想要它，但现在它不是一个优先事项。

有趣的是，

Index

/

IndexMut

和

Deref

/

DerefMut

，存在一定程度的参数易变性，因此可以说锈已经开始起作用了。

#![feature(associated_types)]

pub trait Point2D {
    type value_type;
    fn x_as_mut(&mut self) -> &mut <Self as Point2D>::value_type;
    fn y_as_mut(&mut self) -> &mut <Self as Point2D>::value_type;
    fn x_as_ref(&self) -> &<Self as Point2D>::value_type;
    fn y_as_ref(&self) -> &<Self as Point2D>::value_type;
}

#[deriving(Show)]
pub struct Point2<T> {
    x : T,
    y : T,
}

impl<T> Point2D for Point2<T> {
    type value_type = T;

#[inline]
    fn x_as_mut(&mut self) -> &mut T {
        &mut self.x
    }

#[inline]
    fn y_as_mut(&mut self) -> &mut T {
        &mut self.y
    }
#[inline]
    fn x_as_ref(&self) -> &T {
        &self.x
    }

#[inline]
    fn y_as_ref(&self) -> &T {
        &self.y
    }
}

trait Channel {

}

fn main(){
    let mut p1 = Point2{x: 0i32, y : 0i32};

    println!("p1 = {}", p1);

    *p1.x_as_mut() = 1i32;

    println!("p1 = {}", p1);

    let p2 = Point2{x:0u8, y:10u8};

    println!("p2 = {}", p2.y_as_ref());

}