Why is there no nested reference to forcing an array to a fragment?

Question

I am reading What are the correct Rust auto dereferencing rules? from start to finish, but I still have a question about coercion from array to slice.

Let's look at the following code:

let arr: &[i32; 5] = &&&[1, 2, 3, 4, 5]; // let arr: &[i32] = &&&[1, 2, 3, 4, 5]; // Error; expected slice, found reference 

I would expect &&&[1, 2, 3, 4, 5] have a type, &&&[i32; 5] &&&[i32; 5] and dereferencing &&[i32; 5] &&[i32; 5] => &[i32; 5] &[i32; 5] => &[i32; 5] &[i32; 5] => &[i32] , but the result is different than expected.

I tried to run the following code:

 let arr: &&&[i32; 5] = &&&[1, 2, 3, 4, 5]; let n = arr.first().unwrap(); // 1 

This is the correct code. The arr type is forced to &&&[i32; 5] &&&[i32; 5] => &&[i32; 5] &&[i32; 5] => &[i32; 5] &[i32; 5] => &[i32] and matches the first argument first in slice, &self .

What is the condition that massages cutting constraints? I do not understand the difference between the first and last code.

I also checked the documentation in the source code and suggested that the above question has something to do with the sentence below;

However, we sometimes perform other corrections and coercions along this path, in particular insensitive (for example, the conversion from [T; n] to [T]).

Answer 1

This type of coercion is intended to work, but not implemented.

Arrays do not implement Deref , so the cast &[T; n] → &[T] &[T; n] → &[T] &[T; n] → &[T] &[T; n] → &[T] not a forced application and does not work the same as one. Instead, it is called "unregulated coercion" because it turns a dimensional type ( [T; n] ) into a non-standard type ( [T] ).

However, the language reference (which is not normative and may be outdated, but bear with me) lists possible coercive measures, including the following:

• T_1 T_3 where T_1 leads to T_2 and T_2 T_3 to T_3 (transition case)

  Please note that this is not yet fully supported.

• &T to &U if T implements Deref<Target = U> .

• TyCtor ( T ) - TyCtor ( U ), where TyCtor ( T ) is one of

  • &T
  • &mut T
  • *const T
  • *mut T
  • Box<T>

  and where T can be obtained from U using uneven coercion .

The last bullet, non-standard coercion, is what &[T; n] &[T; n] &[T; n] &[T; n] to force &[T] . Remarkably, this describes only one level of links; this does not apply to &&[T; n] &&[T; n] &&[T; n] &&[T; n] → &[T] case (for which we also need to force cast to Deref ).

Back to your inoperative example:

 let arr: &[i32] = &&&[1, 2, 3, 4, 5]; 

Alleged coercion - &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] → &[i32] . We can understand how this coercion should work:

1. &[i32; 5] &[i32; 5] &[i32; 5] &[i32; 5] forces &[i32] to size;
2. &&[i32; 5] &&[i32; 5] &&[i32; 5] &&[i32; 5] forces to &[i32; 5] &[i32; 5] &[i32; 5] &[i32; 5] Deref ;
3. therefore, &&[i32; 5] &&[i32; 5] &&[i32; 5] &&[i32; 5] leads to &[i32] transitivity .
4. &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] forces &&[i32; 5] &&[i32; 5] &&[i32; 5] &&[i32; 5] Deref ;
5. therefore, &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] leads to &[i32] transitivity .

But this is not so. The above quote hints at why: the transition case says: "Please note that this is not yet fully supported." As far as I can tell, according to issue No. 18602 , “not fully supported” is a hedge; it would be more accurate to say "not implemented." So, at the moment, coercion through transitivity is generally impossible. Obviously, this problem is not a priority, perhaps because dimensional arrays are not very common. (I suspect this may become a more common complaint when constant generics land, as this may make arrays more useful.)

So why does arr.first() work? Well, the "auto-detection rules" used to find methods invoked with . (dot) operator is an extension of coercion rules. Autoderef is like manually dereferencing any number of times until you get something (which can be cast to) using this method. This means that you don’t need transitivity to search for method calls through autoderef (which RFC 401 calls "pushing").

---

further reading

RFC # 401 describes the alleged semantics of most coercions. This RFC was merged more than 4 years ago. Since then, much has changed, but it is still not fully implemented (tracking issue # 18469 ), so RFC 401 does not accurately describe any past, present or future version of Rust. However, RFC 401 also allows the use of &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] &&&[i32; 5] to &[i32] and almost the same logic.

Rustonomicon also has a chapter on coercion and seems to agree with the guide.