Início / coding / Perguntas / 78082942
Accepted
Mad Physicist
Asked: 2024-03-01 00:30:08 +0800 CST

Acessando o contante associado na declaração de campo da estrutura genérica

  • 772

Eu tenho uma característica de tag que possui uma constante associada:

trait Trait {
    const N: usize;
}

Eu tenho um tipo genérico, limitado pela característica. Eu gostaria de poder usar Nna declaração:

struct S<T: Trait> {
    field: [f64; T::N],
}

Minha expectativa é que, para qualquer implementação Traitque especifique N, eu possa ter um Sarray com tantos carros alegóricos nele. Em vez disso, recebo o seguinte erro do compilador:

error: generic parameters may not be used in const operations
 --> src/main.rs:8:18
  |
8 |     field: [f64; T::N],
  |                  ^^^^ cannot perform const operation using `T`
  |
  = note: type parameters may not be used in const expressions

error[E0392]: parameter `T` is never used
 --> src/main.rs:7:10
  |
7 | struct S<T: Trait> {
  |          ^ unused parameter
  |
  = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`

For more information about this error, try `rustc --explain E0392`.

Embora eu entenda o erro em si, não entendo o motivo ou como contorná-lo.

generics

3 respostas

  1. Best Answer

    Uma solução alternativa para usar um tipo associado é usar typenumnúmeros inteiros:

    use nalgebra::base::dimension::{ToConst, U1};
use nalgebra::base::storage::{IsContiguous, RawStorageMut, Storage};
use nalgebra::base::{Matrix, Scalar};

trait ToVectorArrayStorage: ToConst {
    type ArrayStorage<T: Scalar>: RawStorageMut<T, <Self as ToConst>::Const>
        + Storage<T, <Self as ToConst>::Const>
        + IsContiguous;
}

macro_rules! impl_to_vector_array_storage {
    ( $( $num:literal => $typenum:ident, )* ) => {
        $(
            impl ToVectorArrayStorage for typenum::$typenum {
                type ArrayStorage<T: Scalar> = nalgebra::base::ArrayStorage<T, $num, 1>;
            }
        )*
    }
}
impl_to_vector_array_storage! {
    0=>U0, 1=>U1, 2=>U2, 3=>U3, 4=>U4, 5=>U5, 6=>U6, 7=>U7, 8=>U8, 9=>U9, 10=>U10,
    11=>U11, 12=>U12, 13=>U13, 14=>U14, 15=>U15, 16=>U16, 17=>U17, 18=>U18,
    19=>U19, 20=>U20,
}

trait Trait {
    type N: ToVectorArrayStorage;
}

type TypenumVector<T, N> =
    Matrix<T, <N as ToConst>::Const, U1, <N as ToVectorArrayStorage>::ArrayStorage<f64>>;

struct S<T: Trait> {
    field: TypenumVector<f64, T::N>,
}

    Parque infantil .

    • 1

  2. Embora não seja o ideal, tomei o comentário de Chayim Friedman como uma solução possível. Em vez de fazer com que o tipo associado seja uma constante indicando o número de elementos, pode ser o próprio tipo de armazenamento:

    trait Trait {
    type Buffer;
}

struct S<T: Trait> {
    field: T::Buffer,
}
    • 0

  3. O traitprecisa de um implpara definir isso const N.

    Experimente isto:

    trait MyTrait {
    const NN: usize;
}

struct MyStruct {
    abc: [f64; <MyStruct as MyTrait>::NN],
}

impl MyTrait for MyStruct {
    const NN: usize = 4;
}

fn use_nn<T: MyTrait>(_t: &T) -> usize {
    T::NN
}

fn main() {
    let a = MyStruct { abc: [1. ,2., 3., 4.] };
    let v = use_nn(&a);
    
    assert_eq!(v, 4); // passes
    assert_eq!(a.abc[0], 1.0); // passes
    
    let a = MyStruct { abc: [1. ,2., 3., 4., 5.] };
    /// error: ^^^^^^^^^^^^^^^^^^^^ expected an array with a fixed size of 4 elements, found one with 5 elements

}
    • 0

relate perguntas