有没有一种方法可以“超载”使用相同的方法，但具有不同的参数？

Question

这是美好的一天，直到我看到Python的TKINTER能够获取/设置数据的能力，如下所示：

k = some_object(inner=7)
print(k.inner()) # Gets the value, prints 7
k.inner(4) # Sets the value
print(k.inner()) # 4

我印象深刻 - 非常酷！无需编写所有这些讨厌的set_data或get_data，只是一种决定本身可以做什么的方法！

但是后来我在Rust尝试了同样的事情。 首先，内部不能成为一个函数，因为Rust的功能不支持过载。通常通过手动实现fnonce，fnmut和fn在某些单元类型上，然后声明该单元的常数（请参见 Overloadf板条箱）。尽管它需要一些每晚的功能，但我目前正在使用夜间生锈，因此这不是问题。

但是是的问题是，方法是将self作为参数（这就是为什么它是方法而不是函数），并且您不能使用点表示法：

#![feature(fn_traits, unboxed_closures)]

/// Some `sort` of a function
pub struct Functor;

impl FnOnce for Functor { ... }

impl FnMut for Functor { ... }

impl Fn for Functor { ... }

#[allow(#[allow(non_upper_case_globals)])]
pub const i_am_a_normal_function_trust_me: Functor = Functor;

// ...

i_am_a_normal_function_trust_me() // Yay! Could be called!

pub struct Wrapper(());

impl Wrapper {
    /// Let's just say that `Functor` takes a `&Wrapper`
    #[allow(non_upper_case_globals)]
    pub const method: Functor = Functor;
}

let v = Wrapper(());

// Oopsy, does not work
v.method()

// Only through that ugly notation(which is not what I want)
Wrapper::method(&v)

这不会编译，因此我尝试了另一种方法 - 通过普通特征：

pub trait GetInner <T> {
    fn inner(&self) -> &T;
}

pub trait SetInner <T> {
    fn inner(&mut self, inner: T);
}

pub struct Wrapper <T> (T);

impl <T> GetInner <T> for Wrapper <T> {
    fn inner(&self) -> &T {
        &self.0
    }
}

impl <T> SetInner <T> for Wrapper <T> {
    fn inner(&mut self, inner: T) {
        self.0 = inner
    }
}

fn main() {
    let mut v = Wrapper(0);
    dbg!(v.inner());
    v.inner(4); // error[E0061]: this function takes 0 arguments but 1 argument was supplied
    dbg!(v.inner());
    v.inner(v.inner() + 2); // error[E0061]: this function takes 0 arguments but 1 argument was supplied
    dbg!(v.inner());
}

因此，编译器无法区分单独特征的方法，即使它们的签名完全不同！

好的，尝试，不错，尝试...但是 polska 这个想法尚未丢失！

这次，我注意到编译器仅抱怨setInner并尝试交换含义：

pub trait GetInner <T> {
    fn inner(&mut self) -> &T;
}

pub trait SetInner <T> {
    fn inner(&mut self, inner: T);
}

pub struct Wrapper <T> (T);

/// Swappy swap
impl <T> SetInner <T> for Wrapper <T> {
    fn inner(&mut self, inner: T) {
        self.0 = inner
    }
}

/// Swappy swap
impl <T> GetInner <T> for Wrapper <T> {
    fn inner(&mut self) -> &T {
        &self.0
    }
}

fn main() {
    let mut v = Wrapper(0);
    dbg!(v.inner()); // error[E0034]: multiple applicable items in scope
    v.inner(4); // error[E0034]: multiple applicable items in scope
    dbg!(v.inner()); // error[E0034]: multiple applicable items in scope
    v.inner(v.inner() + 2); // error[E0034]: multiple applicable items in scope x 2
    dbg!(v.inner()); // error[E0034]: multiple applicable items in scope
}

怪异，错误现在完全不同。但这对我没有帮助...

我从上方寻求一个明亮的指导：有什么方法可以将我的愿望实现到现实，还是目前的生锈（甚至每晚）还没有为这种“先进技术”做好准备？

Answer 1

不。不要在生锈中实施过载。甚至不要尝试。这不是一个很好的Rust API设计。生锈不使用过载。生锈不应使用过载。使用特质。

---

当然，但是，我们可以吗？

特征方法不适用于 + 特征，但它将与a 单一通用性特征（尽管呼叫不便利）：

trait Overload<Args> {
    type Output;
    fn foo(&mut self, args: Args) -> Self::Output;
}

struct Data(i32);

impl Overload<()> for Data {
    type Output = i32;
    fn foo(&mut self, (): ()) -> i32 { self.0 }
}

impl Overload<(i32,)> for Data {
    type Output = ();
    fn foo(&mut self, (v,): (i32,)) { self.0 = v; }
}

fn main() {
    let mut v = Data(0);
    v.foo((123,));
    dbg!(v.foo(()));
}

我还没有（？）找到一种使fn*方法可悲的方法。

Answer 2

模仿 Rustier 方式的TKINTER能力：
如op所述 - 允许 fn innit（） self self 参数可能不是相互的。

use std::cell::RefCell;

struct SomeObject<T> {
    inner: RefCell<T>,
}

impl SomeObject<i32> {
    fn new() -> SomeObject<i32> {
        SomeObject { inner: RefCell::new(0), }
    }

    fn inner(&self, opt: Option<i32>) -> i32 {
        match opt {
            Some(n) => { *self.inner.borrow_mut() = n; n },
            None    => { *self.inner.borrow() },
        }
    }
}

fn main() {
    let some_object = SomeObject::new();
    some_object.inner(Some(123));
    println!("{}", some_object.inner(Some(some_object.inner(None) + 2)));  // 125
}