É verdade que para todos os tipos `T`,` U` se `T` for coagido para` U` então `& T` será coagido para` & U`?
É bem documentado que [T; n]
pode coagir a [T]
. O código a seguir também está bem formado :
fn test(){
let _a: &[i32] = &[1, 2, 3];
}
Aqui temos que &[T; n]
é coagido a &[T]
.
É verdade que, para todos os tipos T
, U
se T
é coagido a, U
então &T
é coagido a &U
?
Não está documentado na referência (pelo menos explicitamente).
Respostas
Não, porque adicionar mais uma camada de &
causa a falha:
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]`
Além disso, não é o caso que [T; n]
coage a [T]
no mesmo sentido que &[T; n]
coage a &[T]
. A documentação que você vinculou descreve as duas características relacionadas a coerções não dimensionadas: Unsize
e CoerceUnsized
. [T; n]
implementos Unsize<[T]>
e, portanto, &[T; n]
implementos CoerceUnsized<&[T]>
; isso é essencialmente a mesma coisa, e seu código demonstra ambos com eficácia. Não seria possível escrever uma função que coage [T; n]
a [T]
sem usando referências (ou ponteiros de algum tipo) porque coerções unsizing só pode ter lugar por trás algum tipo de ponteiro.