哪种类型对方法的“自我"参数有效? [英] What types are valid for the `self` parameter of a method?

问题描述

我想创建一种仅在self参数为Rc的情况下起作用的方法.我看到可以使用Box，所以我想我可以尝试模仿它的工作原理:

I wanted to create a method that only works where the self parameter was an Rc. I saw that I could use Box, so I thought I might try to mimic how that works:

use std::rc::Rc;
use std::sync::Arc;

struct Bar;

impl Bar {
    fn consuming(self) {}
    fn reference(&self) {}
    fn mutable_reference(&mut self) {}
    fn boxed(self: Box<Bar>) {}
    fn ref_count(self: Rc<Bar>) {}
    fn atomic_ref_count(self: Arc<Bar>) {}
}

fn main() {}

产生这些错误:

error[E0308]: mismatched method receiver
  --> a.rs:11:18
   |
11 |     fn ref_count(self: Rc<Bar>) {}
   |                  ^^^^ expected struct `Bar`, found struct `std::rc::Rc`
   |
   = note: expected type `Bar`
   = note:    found type `std::rc::Rc<Bar>`

error[E0308]: mismatched method receiver
  --> a.rs:12:25
   |
12 |     fn atomic_ref_count(self: Arc<Bar>) {}
   |                         ^^^^ expected struct `Bar`, found struct `std::sync::Arc`
   |
   = note: expected type `Bar`
   = note:    found type `std::sync::Arc<Bar>`

这是Rust 1.15.1的版本.

This is with Rust 1.15.1.

推荐答案

在Rust 1.33之前，只有四个有效的方法接收者:

Before Rust 1.33, there are only four valid method receivers:

struct Foo;

impl Foo {
    fn by_val(self: Foo) {} // a.k.a. by_val(self)
    fn by_ref(self: &Foo) {} // a.k.a. by_ref(&self)
    fn by_mut_ref(self: &mut Foo) {} // a.k.a. by_mut_ref(&mut self)
    fn by_box(self: Box<Foo>) {} // no short form
}

fn main() {}

最初，Rust没有这种明确的self形式，仅self，&self，&mut self和~self(Box的旧名称).进行了更改，以使仅按值和按引用具有简短的内置语法，因为它们是常见情况，并且具有非常关键的语言属性，而所有智能指针(包括Box)都需要显式形式

Originally, Rust didn't have this explicit self form, only self, &self, &mut self and ~self (the old name for Box). This changed so that only by-value and by-references have the short-hand built-in syntax, since they are the common cases, and have very key language properties, while all smart pointers (including Box) require the explicit form.

从Rust 1.33开始，一些其他选定类型可用作self:

As of Rust 1.33, some additional selected types are available for use as self:

• Rc
• Arc
• Pin

• Rc
• Arc
• Pin

这意味着原始示例现在可以工作:

This means that the original example now works:

use std::{rc::Rc, sync::Arc};

struct Bar;

impl Bar {
    fn consuming(self)                  { println!("self") }
    fn reference(&self)                 { println!("&self") }
    fn mut_reference(&mut self)         { println!("&mut self") }
    fn boxed(self: Box<Bar>)            { println!("Box") }
    fn ref_count(self: Rc<Bar>)         { println!("Rc") }
    fn atomic_ref_count(self: Arc<Bar>) { println!("Arc") }
}

fn main() {
    Bar.consuming();
    Bar.reference();
    Bar.mut_reference();
    Box::new(Bar).boxed();
    Rc::new(Bar).ref_count();
    Arc::new(Bar).atomic_ref_count();
}

但是，尚未完全归纳impl处理以匹配语法，因此用户创建的类型仍然不起作用.正在功能标记arbitrary_self_types上取得进展，并且正在跟踪中进行讨论问题44874 .

However, the impl handling hasn't yet been fully generalised to match the syntax, so user-created types still don't work. Progress on this is being made under the feature flag arbitrary_self_types and discussion is taking place in the tracking issue 44874.

(期待的事情！)

这篇关于哪种类型对方法的“自我"参数有效?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！