Is it true that for all types `T`, `U` if `T` is coerced to `U` then `&T` is coerced to `&U`?

Question

It's well documented that [T; n] can coerce to [T]. The following code is also well-formed:

fn test(){
    let _a: &[i32] = &[1, 2, 3];
}

Here we have that &[T; n] is coerced to &[T].

Is it true that for all types T, U if T is coerced to U then &T is coerced to &U?

It's not documented in the reference (at least explicitly).

@PeterHall That's true and is well-docuemeted. The question is what rule governs the `&[T; n]` to `&[T]`? — Some Name, Aug 17 '20 at 13:58
This is actually kind of documented on the page you linked – `CoerceUnsized<&U> for &T` is implemented for `T: Unsize`, which implies that the coercion in your example exists. — Sven Marnach, Aug 17 '20 at 13:59
It may be slightly clearer in the Nomicon: https://doc.rust-lang.org/nomicon/coercions.html — Sven Marnach, Aug 17 '20 at 13:59
And from the same page: `&T` or `&mut T` to `&U` if `T` implements `Deref`. — Peter Hall, Aug 17 '20 at 14:00
@SvenMarnach Thanks. If you posted it as an answer I would accept it. — Some Name, Aug 17 '20 at 14:00
See also [How does the mechanism behind the creation of boxed traits work?](https://stackoverflow.com/q/52288980/155423) — Shepmaster, Aug 17 '20 at 14:15

score 5 · Accepted Answer · answered Aug 17 '20 at 19:54

No, because adding one more layer of & causes it to fail:

fn oops() {
    let a: &[i32; 3] = &[1, 2, 3];
    let _b: &&[i32] = &a;
}

error[E0308]: mismatched types
 --> src/lib.rs:8:23
  |
8 |     let _b: &&[i32] = &a;
  |             -------   ^^ expected slice `[i32]`, found array `[i32; 3]`
  |             |
  |             expected due to this
  |
  = note: expected reference `&&[i32]`
             found reference `&&[i32; 3]`

Further, it is not the case that [T; n] coerces to [T] in the same sense that &[T; n] coerces to &[T]. The documentation you linked describes the two traits related to unsized coercions: Unsize and CoerceUnsized. [T; n] implements Unsize<[T]>, and therefore &[T; n] implements CoerceUnsized<&[T]>; this is essentially the same thing, and your code effectively demonstrates both. It would not be possible to write a function that coerces [T; n] to [T] without using references (or pointers of some sort) because unsizing coercions only take place behind some kind of pointer.

Essentially, an unsized coercion always converts some kind of _pointer_ into a _fat pointer_. The documentation is indeed somewhat confusingly worded and could be imporved. — Sven Marnach, Aug 17 '20 at 20:15

Is it true that for all types `T`, `U` if `T` is coerced to `U` then `&T` is coerced to `&U`?

1 Answers1

Linked