É verdade que para todos os tipos `T`,` U` se `T` for coagido para` U` então `& T` será coagido para` & U`?

Aug 17 2020

É 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, Use Té coagido a, Uentão &Té coagido a &U?

Não está documentado na referência (pelo menos explicitamente).

Respostas

5 trentcl Aug 17 2020 at 19:54

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: Unsizee 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.