What are Rust's exact auto-dereferencing rules?

前端未结

关注

 2  1189

忘了有多久 2020-11-21 22:36

I\'m learning/experimenting with Rust, and in all the elegance that I find in this language, there is one peculiarity that baffles me and seems totally out of place.

2条回答

梦如初夏 (楼主)

2020-11-21 23:14
The Rust reference has a chapter about the method call expression. I copied the most important part below. Reminder: we are talking about an expression recv.m(), where recv is called "receiver expression" below.
The first step is to build a list of candidate receiver types. Obtain these by repeatedly dereferencing the receiver expression's type, adding each type encountered to the list, then finally attempting an unsized coercion at the end, and adding the result type if that is successful. Then, for each candidate T, add &T and &mut T to the list immediately after T.

For instance, if the receiver has type Box<[i32;2]>, then the candidate types will be Box<[i32;2]>, &Box<[i32;2]>, &mut Box<[i32;2]>, [i32; 2] (by dereferencing), &[i32; 2], &mut [i32; 2], [i32] (by unsized coercion), &[i32], and finally &mut [i32].

Then, for each candidate type T, search for a visible method with a receiver of that type in the following places:
1. T's inherent methods (methods implemented directly on T [¹]).
2. Any of the methods provided by a visible trait implemented by T. [...]
(Note about [¹]: I actually think this phrasing is wrong. I've opened an issue. Let's just ignore that sentence in the parenthesis.)

Let's go through a few examples from your code in detail! For your examples, we can ignore the part about "unsized coercion" and "inherent methods".

(*X{val:42}).m(): the receiver expression's type is i32. We perform these steps:
- Creating list of candidate receiver types:
  - i32 cannot be dereferenced, so we are already done with step 1. List: [i32]
  - Next, we add &i32 and &mut i32. List: [i32, &i32, &mut i32]
- Searching for methods for each candidate receiver type:
  - We find ::m which has the receiver type i32. So we are already done.
So far so easy. Now let's pick a more difficult example: (&&A).m(). The receiver expression's type is &&A. We perform these steps:
- Creating list of candidate receiver types:
  - &&A can be dereferenced to &A, so we add that to the list. &A can be dereferenced again, so we also add A to the list. A cannot be dereferenced, so we stop. List: [&&A, &A, A]
  - Next, for each type T in the list, we add &T and &mut T immediately after T. List: [&&A, &&&A, &mut &&A, &A, &&A, &mut &A, A, &A, &mut A]
- Searching for methods for each candidate receiver type:
  - There is no method with receiver type &&A, so we go to the next type in the list.
  - We find the method <&&&A as M>::m which indeed has the receiver type &&&A. So we are done.
Here are the candidate receiver lists for all of your examples. The type that is enclosed in ⟪x⟫ is the one that "won", i.e. the first type for which a fitting method could be found. Also remember that the first type in the list is always the receiver expression's type. Lastly, I formatted the list in lines of three, but that's just formatting: this list is a flat list.
- (*X{val:42}).m() → ::m
```
[⟪i32⟫, &i32, &mut i32]
```
- X{val:42}.m() → ::m
```
[⟪X⟫, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&X{val:42}).m() → <&X as M>::m
```
[⟪&X⟫, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&X{val:42}).m() → <&&X as M>::m
```
[⟪&&X⟫, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&X{val:42}).m() → <&&&X as M>::m
```
[⟪&&&X⟫, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&&X{val:42}).m() → <&&&X as M>::m
```
[&&&&X, &&&&&X, &mut &&&&X, 
 ⟪&&&X⟫, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&&&X{val:42}).m() → <&&&X as M>::m
```
[&&&&&X, &&&&&&X, &mut &&&&&X, 
 &&&&X, &&&&&X, &mut &&&&X, 
 ⟪&&&X⟫, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (*X{val:42}).refm() → ::refm
```
[i32, ⟪&i32⟫, &mut i32]
```
- X{val:42}.refm() → ::refm
```
[X, ⟪&X⟫, &mut X, 
 i32, &i32, &mut i32]
```
- (&X{val:42}).refm() → ::refm
```
[⟪&X⟫, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&X{val:42}).refm() → <&X as RefM>::refm
```
[⟪&&X⟫, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&X{val:42}).refm() → <&&X as RefM>::refm
```
[⟪&&&X⟫, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&&X{val:42}).refm() → <&&&X as RefM>::refm
```
[⟪&&&&X⟫, &&&&&X, &mut &&&&X, 
 &&&X, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- (&&&&&X{val:42}).refm() → <&&&X as RefM>::refm
```
[&&&&&X, &&&&&&X, &mut &&&&&X, 
 ⟪&&&&X⟫, &&&&&X, &mut &&&&X, 
 &&&X, &&&&X, &mut &&&X, 
 &&X, &&&X, &mut &&X, 
 &X, &&X, &mut &X, 
 X, &X, &mut X, 
 i32, &i32, &mut i32]
```
- Y{val:42}.refm() → ::refm
```
[Y, &Y, &mut Y,
 i32, ⟪&i32⟫, &mut i32]
```
- Z{val:Y{val:42}}.refm() → ::refm
```
[Z, &Z, &mut Z,
 Y, &Y, &mut Y,
 i32, ⟪&i32⟫, &mut i32]
```
0 讨论(0)

查看其它2个回答
发布评论:

提交评论
- 加载中...