¿Es cierto que para todos los tipos `T`,` U` si `T` se convierte en` U`, entonces `& T` se convierte en` & U`?
Está bien documentado que [T; n]
puede coaccionar [T]
. El siguiente código también está bien formado :
fn test(){
let _a: &[i32] = &[1, 2, 3];
}
Aquí tenemos que &[T; n]
es coaccionado &[T]
.
¿Es cierto que para todos los tipos T
, U
si T
se coacciona a, U
entonces &T
se coacciona &U
?
No está documentado en la referencia (al menos explícitamente).
Respuestas
No, porque agregar una capa más de &
hace que falle:
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]`
Además, no es el caso que [T; n]
coacciona a [T]
en el mismo sentido que &[T; n]
coacciona a &[T]
. La documentación que vinculó describe los dos rasgos relacionados con las coacciones sin tamaño: Unsize
y CoerceUnsized
. [T; n]
implementos Unsize<[T]>
y, por tanto, &[T; n]
implementos CoerceUnsized<&[T]>
; esto es esencialmente lo mismo, y su código demuestra ambos de manera efectiva. No sería posible escribir una función que coacciona [T; n]
a [T]
sin el uso de referencias (o punteros de algún tipo), porque coacciones unsizing solamente tienen lugar a algún tipo de puntero.